firebase-tools 11.2.1 → 11.4.0

package/lib/deploy/hosting/convertConfig.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertConfig = void 0;
 const error_1 = require("../../error");
 const backend_1 = require("../functions/backend");
+const backend = require("../functions/backend");
 function has(obj, k) {
     return obj[k] !== undefined;
 }
@@ -39,24 +40,66 @@ async function convertConfig(context, payload, config, finalize) {
     if (!config) {
         return out;
     }
-    const endpointBeingDeployed = (serviceId, region = "us-central1") => {
-        var _a;
+    const endpointFromBackend = (targetBackend, functionsEndpointInfo) => {
+        const backendsForId = backend.allEndpoints(targetBackend).filter((endpoint) => {
+            return endpoint.id === functionsEndpointInfo.serviceId;
+        });
+        const matchingBackends = backendsForId.filter((endpoint) => {
+            return ((!functionsEndpointInfo.region || endpoint.region === functionsEndpointInfo.region) &&
+                (!functionsEndpointInfo.platform || endpoint.platform === functionsEndpointInfo.platform));
+        });
+        if (matchingBackends.length > 1) {
+            throw new error_1.FirebaseError(`More than one backend found for function name: ${functionsEndpointInfo.serviceId}. If the function is deployed in multiple regions, you must specify a region.`);
+        }
+        if (matchingBackends.length === 1) {
+            const endpoint = matchingBackends[0];
+            if (endpoint && (0, backend_1.isHttpsTriggered)(endpoint)) {
+                return endpoint;
+            }
+        }
+        return;
+    };
+    const endpointBeingDeployed = (functionsEndpointInfo) => {
         for (const { wantBackend } of Object.values(payload.functions || {})) {
-            const endpoint = (_a = wantBackend === null || wantBackend === void 0 ? void 0 : wantBackend.endpoints[region]) === null || _a === void 0 ? void 0 : _a[serviceId];
-            if (endpoint && (0, backend_1.isHttpsTriggered)(endpoint) && endpoint.platform === "gcfv2")
+            if (!wantBackend) {
+                continue;
+            }
+            const endpoint = endpointFromBackend(wantBackend, functionsEndpointInfo);
+            if (endpoint) {
                 return endpoint;
+            }
         }
-        return undefined;
+        return;
     };
-    const matchingEndpoint = async (serviceId, region = "us-central1") => {
-        const pendingEndpoint = endpointBeingDeployed(serviceId, region);
+    const matchingEndpoint = async (functionsEndpointInfo) => {
+        const pendingEndpoint = endpointBeingDeployed(functionsEndpointInfo);
         if (pendingEndpoint)
             return pendingEndpoint;
         const backend = await (0, backend_1.existingBackend)(context);
         return (0, backend_1.allEndpoints)(backend).find((it) => (0, backend_1.isHttpsTriggered)(it) &&
-            it.platform === "gcfv2" &&
-            it.id === serviceId &&
-            it.region === region);
+            it.id === functionsEndpointInfo.serviceId &&
+            (!functionsEndpointInfo.platform || it.platform === functionsEndpointInfo.platform) &&
+            (!functionsEndpointInfo.region || it.region === functionsEndpointInfo.region));
+    };
+    const findEndpointWithValidRegion = async (rewrite, context) => {
+        if ("function" in rewrite) {
+            const foundEndpointToBeDeployed = endpointBeingDeployed({
+                serviceId: rewrite.function,
+                region: rewrite.region,
+            });
+            if (foundEndpointToBeDeployed) {
+                return foundEndpointToBeDeployed;
+            }
+            const existingBackend = await backend.existingBackend(context);
+            const endpointAlreadyDeployed = endpointFromBackend(existingBackend, {
+                serviceId: rewrite.function,
+                region: rewrite.region,
+            });
+            if (endpointAlreadyDeployed) {
+                return endpointAlreadyDeployed;
+            }
+        }
+        return;
     };
     if (Array.isArray(config.rewrites)) {
         out.rewrites = [];
@@ -66,19 +109,30 @@ async function convertConfig(context, payload, config, finalize) {
                 vRewrite.path = rewrite.destination;
             }
             else if ("function" in rewrite) {
-                if (!finalize && endpointBeingDeployed(rewrite.function, rewrite.region))
+                if (!finalize &&
+                    endpointBeingDeployed({
+                        serviceId: rewrite.function,
+                        platform: "gcfv2",
+                        region: rewrite.region,
+                    })) {
                     continue;
-                const endpoint = await matchingEndpoint(rewrite.function, rewrite.region);
+                }
+                const endpoint = await matchingEndpoint({
+                    serviceId: rewrite.function,
+                    platform: "gcfv2",
+                    region: rewrite.region,
+                });
                 if (endpoint) {
                     vRewrite.run = { serviceId: endpoint.id, region: endpoint.region };
                 }
                 else {
                     vRewrite.function = rewrite.function;
-                    if (rewrite.region) {
-                        vRewrite.functionRegion = rewrite.region;
+                    const foundEndpoint = await findEndpointWithValidRegion(rewrite, context);
+                    if (foundEndpoint) {
+                        vRewrite.functionRegion = foundEndpoint.region;
                     }
                     else {
-                        vRewrite.functionRegion = "us-central1";
+                        throw new error_1.FirebaseError(`Unable to find a valid endpoint for function ${vRewrite.function}`);
                     }
                 }
             }
@@ -86,8 +140,14 @@ async function convertConfig(context, payload, config, finalize) {
                 vRewrite.dynamicLinks = rewrite.dynamicLinks;
             }
             else if ("run" in rewrite) {
-                if (!finalize && endpointBeingDeployed(rewrite.run.serviceId, rewrite.run.region))
+                if (!finalize &&
+                    endpointBeingDeployed({
+                        serviceId: rewrite.run.serviceId,
+                        platform: "gcfv2",
+                        region: rewrite.run.region,
+                    })) {
                     continue;
+                }
                 vRewrite.run = Object.assign({ region: "us-central1" }, rewrite.run);
             }
             out.rewrites.push(vRewrite);

package/lib/deploy/index.js

@@ -52,7 +52,7 @@ const deploy = async function (targetNames, options, customContext = {}) {
     for (const targetName of targetNames) {
         const target = TARGETS[targetName];
         if (!target) {
-            return Promise.reject(new error_1.FirebaseError((0, cli_color_1.bold)(targetName) + " is not a valid deploy target", { exit: 1 }));
+            return Promise.reject(new error_1.FirebaseError(`${(0, cli_color_1.bold)(targetName)} is not a valid deploy target`));
         }
         predeploys.push((0, lifecycleHooks_1.lifecycleHooks)(targetName, "predeploy"));
         prepares.push(target.prepare);

package/lib/deploy/lifecycleHooks.js

@@ -31,7 +31,7 @@ function runCommand(command, childOptions) {
                 reject(new Error("Command terminated with signal " + signal));
             }
             else if (code !== 0) {
-                reject(new Error("Command terminated with non-zero exit code" + code));
+                reject(new Error("Command terminated with non-zero exit code " + code));
             }
             else {
                 resolve();

package/lib/deploy/storage/prepare.js

@@ -3,25 +3,48 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const _ = require("lodash");
 const gcp = require("../../gcp");
 const rulesDeploy_1 = require("../../rulesDeploy");
+const error_1 = require("../../error");
 async function default_1(context, options) {
     let rulesConfig = options.config.get("storage");
     if (!rulesConfig) {
         return;
     }
+    const onlyTargets = new Set();
+    let allStorage = !options.only;
+    if (options.only) {
+        const split = options.only.split(",");
+        if (split.includes("storage")) {
+            allStorage = true;
+        }
+        else {
+            for (const value of split) {
+                if (value.startsWith("storage:")) {
+                    onlyTargets.add(value.split(":")[1]);
+                }
+            }
+        }
+    }
     _.set(context, "storage.rules", rulesConfig);
     const rulesDeploy = new rulesDeploy_1.RulesDeploy(options, rulesDeploy_1.RulesetServiceType.FIREBASE_STORAGE);
     _.set(context, "storage.rulesDeploy", rulesDeploy);
-    if (_.isPlainObject(rulesConfig)) {
+    if (!Array.isArray(rulesConfig)) {
         const defaultBucket = await gcp.storage.getDefaultBucket(options.project);
         rulesConfig = [Object.assign(rulesConfig, { bucket: defaultBucket })];
         _.set(context, "storage.rules", rulesConfig);
     }
-    rulesConfig.forEach((ruleConfig) => {
-        if (ruleConfig.target) {
-            options.rc.requireTarget(context.projectId, "storage", ruleConfig.target);
+    for (const ruleConfig of rulesConfig) {
+        const target = ruleConfig.target;
+        if (target) {
+            options.rc.requireTarget(context.projectId, "storage", target);
         }
-        rulesDeploy.addFile(ruleConfig.rules);
-    });
+        if (allStorage || onlyTargets.has(target)) {
+            rulesDeploy.addFile(ruleConfig.rules);
+            onlyTargets.delete(target);
+        }
+    }
+    if (!allStorage && onlyTargets.size !== 0) {
+        throw new error_1.FirebaseError(`Could not find rules for the following storage targets: ${[...onlyTargets].join(", ")}`);
+    }
     await rulesDeploy.compile();
 }
 exports.default = default_1;

package/lib/downloadUtils.js

@@ -20,7 +20,7 @@ async function downloadToTmp(remoteUrl) {
         resolveOnHTTPError: true,
     });
     if (res.status !== 200) {
-        throw new error_1.FirebaseError(`download failed, status ${res.status}`, { exit: 1 });
+        throw new error_1.FirebaseError(`download failed, status ${res.status}: ${await res.response.text()}`);
     }
     const total = parseInt(res.response.headers.get("content-length") || "0", 10);
     const totalMb = Math.ceil(total / 1000000);

package/lib/emulator/controller.js

@@ -301,7 +301,6 @@ async function startAll(options, showUI = true) {
         const extensionsBackends = await extensionEmulator.getExtensionBackends();
         const filteredExtensionsBackends = extensionEmulator.filterUnemulatedTriggers(options, extensionsBackends);
         emulatableBackends.push(...filteredExtensionsBackends);
-        void (0, track_1.track)("Emulator Run", types_1.Emulators.EXTENSIONS);
         await startEmulator(extensionEmulator);
     }
     if (emulatableBackends.length) {

package/lib/emulator/downloadableEmulators.js

@@ -55,7 +55,7 @@ exports.DownloadDetails = {
             version: "SNAPSHOT",
             downloadPath: path.join(CACHE_DIR, "ui-vSNAPSHOT.zip"),
             unzipDir: path.join(CACHE_DIR, "ui-vSNAPSHOT"),
-            binaryPath: path.join(CACHE_DIR, "ui-vSNAPSHOT", "server.bundle.js"),
+            binaryPath: path.join(CACHE_DIR, "ui-vSNAPSHOT", "server", "server.js"),
             opts: {
                 cacheDir: CACHE_DIR,
                 remoteUrl: "https://storage.googleapis.com/firebase-preview-drop/emulator/ui-vSNAPSHOT.zip",
@@ -67,15 +67,15 @@ exports.DownloadDetails = {
             },
         }
         : {
-            version: "1.7.0",
-            downloadPath: path.join(CACHE_DIR, "ui-v1.7.0.zip"),
-            unzipDir: path.join(CACHE_DIR, "ui-v1.7.0"),
-            binaryPath: path.join(CACHE_DIR, "ui-v1.7.0", "server.bundle.js"),
+            version: "1.8.1",
+            downloadPath: path.join(CACHE_DIR, "ui-v1.8.1.zip"),
+            unzipDir: path.join(CACHE_DIR, "ui-v1.8.1"),
+            binaryPath: path.join(CACHE_DIR, "ui-v1.8.1", "server", "server.js"),
             opts: {
                 cacheDir: CACHE_DIR,
-                remoteUrl: "https://storage.googleapis.com/firebase-preview-drop/emulator/ui-v1.7.0.zip",
-                expectedSize: 4053708,
-                expectedChecksum: "aea9ae19091df5974a88a8847aaf127c",
+                remoteUrl: "https://storage.googleapis.com/firebase-preview-drop/emulator/ui-v1.8.1.zip",
+                expectedSize: 3056552,
+                expectedChecksum: "92590fdda20f9883588438d9551111b5",
                 namePrefix: "ui",
             },
         },
@@ -164,7 +164,7 @@ const Commands = {
     },
     ui: {
         binary: "node",
-        args: ["--dns-result-order=ipv4first", getExecPath(types_1.Emulators.UI)],
+        args: [getExecPath(types_1.Emulators.UI)],
         optionalArgs: [],
         joinArgs: false,
     },

package/lib/emulator/functionsEmulator.js

@@ -272,8 +272,13 @@ class FunctionsEmulator {
             await runtimeDelegate.build();
             logger_1.logger.debug(`Analyzing ${runtimeDelegate.name} backend spec`);
             const environment = Object.assign(Object.assign(Object.assign(Object.assign({}, this.getSystemEnvs()), this.getEmulatorEnvs()), { FIREBASE_CONFIG: this.getFirebaseConfig() }), emulatableBackend.env);
+            const userEnvOpt = {
+                functionsSource: emulatableBackend.functionsDir,
+                projectId: this.args.projectId,
+                projectAlias: this.args.projectAlias,
+            };
             const discoveredBuild = await runtimeDelegate.discoverBuild(runtimeConfig, environment);
-            const discoveredBackend = (0, build_1.resolveBackend)(discoveredBuild, environment);
+            const discoveredBackend = await (0, build_1.resolveBackend)(discoveredBuild, userEnvOpt, environment);
             const endpoints = backend.allEndpoints(discoveredBackend);
             (0, functionsEmulatorShared_1.prepareEndpoints)(endpoints);
             for (const e of endpoints) {
@@ -641,6 +646,9 @@ class FunctionsEmulator {
         envs.GCLOUD_PROJECT = this.args.projectId;
         envs.K_REVISION = "1";
         envs.PORT = "80";
+        if (trigger === null || trigger === void 0 ? void 0 : trigger.timeoutSeconds) {
+            envs.FUNCTIONS_EMULATOR_TIMEOUT_SECONDS = trigger.timeoutSeconds.toString();
+        }
         if (trigger) {
             const target = trigger.entryPoint;
             envs.FUNCTION_TARGET = target;

package/lib/emulator/functionsEmulatorRuntime.js

@@ -104,7 +104,7 @@ class Proxied {
         return this.proxy;
     }
 }
-async function resolveDeveloperNodeModule(frb, name) {
+async function resolveDeveloperNodeModule(name) {
     const pkg = requirePackageJson();
     if (!pkg) {
         new types_1.EmulatorLog("SYSTEM", "missing-package-json", "").log();
@@ -130,20 +130,20 @@ async function resolveDeveloperNodeModule(frb, name) {
     logDebug(`Resolved module ${name}`, moduleResolution);
     return moduleResolution;
 }
-async function assertResolveDeveloperNodeModule(frb, name) {
-    const resolution = await resolveDeveloperNodeModule(frb, name);
+async function assertResolveDeveloperNodeModule(name) {
+    const resolution = await resolveDeveloperNodeModule(name);
     if (!(resolution.installed && resolution.declared && resolution.resolution && resolution.version)) {
         throw new Error(`Assertion failure: could not fully resolve ${name}: ${JSON.stringify(resolution)}`);
     }
     return resolution;
 }
-async function verifyDeveloperNodeModules(frb) {
+async function verifyDeveloperNodeModules() {
     const modBundles = [
         { name: "firebase-admin", isDev: false, minVersion: "8.9.0" },
         { name: "firebase-functions", isDev: false, minVersion: "3.13.1" },
     ];
     for (const modBundle of modBundles) {
-        const resolution = await resolveDeveloperNodeModule(frb, modBundle.name);
+        const resolution = await resolveDeveloperNodeModule(modBundle.name);
         if (!resolution.declared) {
             new types_1.EmulatorLog("SYSTEM", "missing-module", "", modBundle).log();
             return false;
@@ -240,8 +240,8 @@ function initializeNetworkFiltering() {
     });
     logDebug("Outgoing network have been stubbed.", results);
 }
-async function initializeFirebaseFunctionsStubs(frb) {
-    const firebaseFunctionsResolution = await assertResolveDeveloperNodeModule(frb, "firebase-functions");
+async function initializeFirebaseFunctionsStubs() {
+    const firebaseFunctionsResolution = await assertResolveDeveloperNodeModule("firebase-functions");
     const firebaseFunctionsRoot = (0, functionsEmulatorShared_1.findModuleRoot)("firebase-functions", firebaseFunctionsResolution.resolution);
     const httpsProviderResolution = path.join(firebaseFunctionsRoot, "lib/providers/https");
     const httpsProviderV1Resolution = path.join(firebaseFunctionsRoot, "lib/v1/providers/https");
@@ -343,10 +343,10 @@ function initializeRuntimeConfig() {
         }
     }
 }
-async function initializeFirebaseAdminStubs(frb) {
-    const adminResolution = await assertResolveDeveloperNodeModule(frb, "firebase-admin");
+async function initializeFirebaseAdminStubs() {
+    const adminResolution = await assertResolveDeveloperNodeModule("firebase-admin");
     const localAdminModule = require(adminResolution.resolution);
-    const functionsResolution = await assertResolveDeveloperNodeModule(frb, "firebase-functions");
+    const functionsResolution = await assertResolveDeveloperNodeModule("firebase-functions");
     const localFunctionsModule = require(functionsResolution.resolution);
     const defaultConfig = getDefaultConfig();
     const adminModuleProxy = new Proxied(localAdminModule);
@@ -360,7 +360,7 @@ async function initializeFirebaseAdminStubs(frb) {
         new types_1.EmulatorLog("SYSTEM", "default-admin-app-used", `config=${defaultAppOptions}`, {
             opts: defaultAppOptions,
         }).log();
-        const defaultApp = makeProxiedFirebaseApp(frb, adminModuleTarget.initializeApp(defaultAppOptions));
+        const defaultApp = makeProxiedFirebaseApp(adminModuleTarget.initializeApp(defaultAppOptions));
         logDebug("initializeApp(DEFAULT)", defaultAppOptions);
         localFunctionsModule.app.setEmulatedAdminApp(defaultApp);
         if (process.env[constants_1.Constants.FIREBASE_AUTH_EMULATOR_HOST]) {
@@ -405,7 +405,7 @@ async function initializeFirebaseAdminStubs(frb) {
         adminResolution,
     });
 }
-function makeProxiedFirebaseApp(frb, original) {
+function makeProxiedFirebaseApp(original) {
     const appProxy = new Proxied(original);
     return appProxy
         .when("firestore", (target) => {
@@ -450,8 +450,8 @@ function warnAboutStorageProd() {
     }
     new types_1.EmulatorLog("WARN_ONCE", "runtime-status", "The Firebase Storage emulator is not running, so calls to Firebase Storage will affect production.").log();
 }
-async function initializeFunctionsConfigHelper(frb) {
-    const functionsResolution = await assertResolveDeveloperNodeModule(frb, "firebase-functions");
+async function initializeFunctionsConfigHelper() {
+    const functionsResolution = await assertResolveDeveloperNodeModule("firebase-functions");
     const localFunctionsModule = require(functionsResolution.resolution);
     logDebug("Checked functions.config()", {
         config: localFunctionsModule.config(),
@@ -487,27 +487,7 @@ function rawBodySaver(req, res, buf) {
 }
 async function processHTTPS(trigger) {
     const ephemeralServer = express();
-    const functionRouter = express.Router();
     await new Promise((resolveEphemeralServer, rejectEphemeralServer) => {
-        const handler = async (req, res) => {
-            try {
-                logDebug(`Ephemeral server handling ${req.method} request`);
-                res.on("finish", () => {
-                    instance.close((err) => {
-                        if (err) {
-                            rejectEphemeralServer(err);
-                        }
-                        else {
-                            resolveEphemeralServer();
-                        }
-                    });
-                });
-                await runHTTPS(trigger, [req, res]);
-            }
-            catch (err) {
-                rejectEphemeralServer(err);
-            }
-        };
         ephemeralServer.enable("trust proxy");
         ephemeralServer.use(bodyParser.json({
             limit: "10mb",
@@ -527,14 +507,39 @@ async function processHTTPS(trigger) {
             limit: "10mb",
             verify: rawBodySaver,
         }));
-        functionRouter.all("*", handler);
-        ephemeralServer.use([`/`, `/*`], functionRouter);
-        logDebug(`Attempting to listen to port: ${process.env.PORT}`);
-        const instance = ephemeralServer.listen(process.env.PORT, () => {
-            logDebug(`Listening to port: ${process.env.PORT}`);
-            new types_1.EmulatorLog("SYSTEM", "runtime-status", "ready", { state: "ready" }).log();
+        let server;
+        function closeServer() {
+            if (server) {
+                server.close((err) => {
+                    if (err) {
+                        rejectEphemeralServer(err);
+                    }
+                    else {
+                        resolveEphemeralServer();
+                    }
+                });
+            }
+        }
+        ephemeralServer.get("/__/health", (req, res) => {
+            res.status(200).send();
         });
-        instance.on("error", rejectEphemeralServer);
+        ephemeralServer.all("/favicon.ico|/robots.txt", (req, res) => {
+            res.on("finish", closeServer);
+            res.status(404).send();
+        });
+        ephemeralServer.all(`/*`, async (req, res) => {
+            try {
+                logDebug(`Ephemeral server handling ${req.method} request`);
+                res.on("finish", closeServer);
+                await runHTTPS(trigger, [req, res]);
+            }
+            catch (err) {
+                rejectEphemeralServer(err);
+            }
+        });
+        server = ephemeralServer.listen(process.env.PORT);
+        logDebug(`Listening to port: ${process.env.PORT}`);
+        server.on("error", rejectEphemeralServer);
     });
 }
 async function processBackground(trigger, frb, signature) {
@@ -587,7 +592,7 @@ async function runHTTPS(trigger, args) {
         return trigger(args[0], args[1]);
     });
 }
-async function moduleResolutionDetective(frb, error) {
+async function moduleResolutionDetective(error) {
     const clues = {
         tsconfigJSON: await requireAsync("./tsconfig.json", { paths: [process.cwd()] }).catch(noOp),
         packageJSON: await requireAsync("./package.json", { paths: [process.cwd()] }).catch(noOp),
@@ -645,7 +650,7 @@ async function invokeTrigger(trigger, frb) {
     clearInterval(timerId);
     new types_1.EmulatorLog("INFO", "runtime-status", `Finished "${FUNCTION_TARGET_NAME}" in ~${Math.max(seconds, 1)}s`).log();
 }
-async function initializeRuntime(frb) {
+async function initializeRuntime() {
     FUNCTION_DEBUG_MODE = process.env.FUNCTION_DEBUG_MODE || "";
     if (!FUNCTION_DEBUG_MODE) {
         FUNCTION_TARGET_NAME = process.env.FUNCTION_TARGET || "";
@@ -659,19 +664,18 @@ async function initializeRuntime(frb) {
             await flushAndExit(1);
         }
     }
-    logDebug(`Disabled runtime features: ${JSON.stringify(frb.disabled_features)}`);
-    const verified = await verifyDeveloperNodeModules(frb);
+    const verified = await verifyDeveloperNodeModules();
     if (!verified) {
         new types_1.EmulatorLog("INFO", "runtime-status", `Your functions could not be parsed due to an issue with your node_modules (see above)`).log();
         return;
     }
     initializeRuntimeConfig();
     initializeNetworkFiltering();
-    await initializeFunctionsConfigHelper(frb);
-    await initializeFirebaseFunctionsStubs(frb);
-    await initializeFirebaseAdminStubs(frb);
+    await initializeFunctionsConfigHelper();
+    await initializeFirebaseFunctionsStubs();
+    await initializeFirebaseAdminStubs();
 }
-async function loadTriggers(frb, serializedFunctionTrigger) {
+async function loadTriggers(serializedFunctionTrigger) {
     let triggerModule;
     if (serializedFunctionTrigger) {
         triggerModule = eval(serializedFunctionTrigger)();
@@ -682,7 +686,7 @@ async function loadTriggers(frb, serializedFunctionTrigger) {
         }
         catch (err) {
             if (err.code !== "ERR_REQUIRE_ESM") {
-                await moduleResolutionDetective(frb, err);
+                await moduleResolutionDetective(err);
                 throw err;
             }
             const modulePath = require.resolve(process.cwd());
@@ -712,9 +716,8 @@ async function handleMessage(message) {
     }
     if (!functionModule) {
         try {
-            await initializeRuntime(runtimeArgs.frb);
             const serializedTriggers = runtimeArgs.opts ? runtimeArgs.opts.serializedTriggers : undefined;
-            functionModule = await loadTriggers(runtimeArgs.frb, serializedTriggers);
+            functionModule = await loadTriggers(serializedTriggers);
         }
         catch (e) {
             logDebug(e);
@@ -748,7 +751,7 @@ async function handleMessage(message) {
         await flushAndExit(1);
     }
 }
-function main() {
+async function main() {
     let lastSignal = new Date().getTime();
     let signalCount = 0;
     process.on("SIGINT", () => {
@@ -762,10 +765,7 @@ function main() {
             process.exit(1);
         }
     });
-    logDebug("Functions runtime initialized.", {
-        cwd: process.cwd(),
-        node_version: process.versions.node,
-    });
+    await initializeRuntime();
     let messageHandlePromise = Promise.resolve();
     process.on("message", (message) => {
         messageHandlePromise = messageHandlePromise
@@ -780,5 +780,15 @@ function main() {
     });
 }
 if (require.main === module) {
-    main();
+    main()
+        .then(() => {
+        logDebug("Functions runtime initialized.", {
+            cwd: process.cwd(),
+            node_version: process.versions.node,
+        });
+    })
+        .catch((err) => {
+        new types_1.EmulatorLog("FATAL", "runtime-error", err.message || err, err).log();
+        return flushAndExit(1);
+    });
 }

package/lib/emulator/functionsRuntimeWorker.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RuntimeWorkerPool = exports.RuntimeWorker = exports.RuntimeWorkerState = void 0;
+const http = require("http");
 const uuid = require("uuid");
 const types_1 = require("./types");
 const events_1 = require("events");
@@ -49,17 +50,11 @@ class RuntimeWorker {
         return this._state;
     }
     set state(state) {
-        if (state === RuntimeWorkerState.BUSY) {
-            this.socketReady = types_1.EmulatorLog.waitForLog(this.runtime.events, "SYSTEM", "runtime-status", (el) => {
-                return el.data.state === "ready";
-            });
-        }
         if (state === RuntimeWorkerState.IDLE) {
             for (const l of this.logListeners) {
                 this.runtime.events.removeListener("log", l);
             }
             this.logListeners = [];
-            this.socketReady = undefined;
         }
         if (state === RuntimeWorkerState.FINISHED) {
             this.runtime.events.removeAllListeners();
@@ -88,9 +83,40 @@ class RuntimeWorker {
             this.stateEvents.once(RuntimeWorkerState.FINISHED, listener);
         });
     }
-    waitForSocketReady() {
-        return (this.socketReady ||
-            Promise.reject(new Error("Cannot call waitForSocketReady() if runtime is not BUSY")));
+    isSocketReady() {
+        return new Promise((resolve, reject) => {
+            const req = http
+                .request({
+                method: "GET",
+                path: "/__/health",
+                socketPath: this.runtime.socketPath,
+            }, () => resolve())
+                .end();
+            req.on("error", (error) => {
+                reject(error);
+            });
+        });
+    }
+    async waitForSocketReady() {
+        const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+        const timeout = new Promise((resolve, reject) => {
+            setTimeout(() => {
+                reject(new error_1.FirebaseError("Failed to load function."));
+            }, 7000);
+        });
+        while (true) {
+            try {
+                await Promise.race([this.isSocketReady(), timeout]);
+                break;
+            }
+            catch (err) {
+                if (["ECONNREFUSED", "ENOENT"].includes(err === null || err === void 0 ? void 0 : err.code)) {
+                    await sleep(100);
+                    continue;
+                }
+                throw err;
+            }
+        }
     }
     log(msg) {
         emulatorLogger_1.EmulatorLogger.forEmulator(types_1.Emulators.FUNCTIONS).log("DEBUG", `[worker-${this.key}-${this.id}]: ${msg}`);

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

@@ -324,7 +324,7 @@ function sendFileBytes(md, data, req, res) {
     res.setHeader("Accept-Ranges", "bytes");
     res.setHeader("Content-Type", md.contentType);
     res.setHeader("Content-Disposition", md.contentDisposition);
-    res.setHeader("Content-Encoding", md.contentEncoding);
+    res.setHeader("Content-Encoding", isGZipped ? "identity" : md.contentEncoding);
     res.setHeader("ETag", md.etag);
     res.setHeader("Cache-Control", md.cacheControl);
     res.setHeader("x-goog-generation", `${md.generation}`);