firebase-tools 10.1.5 → 10.2.2

package/lib/emulator/functionsEmulatorRuntime.js

@@ -1,15 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const fs = require("fs");
-const types_1 = require("./types");
-const functionsEmulatorShared_1 = require("./functionsEmulatorShared");
-const functionsEmulatorUtils_1 = require("./functionsEmulatorUtils");
 const express = require("express");
 const path = require("path");
 const bodyParser = require("body-parser");
 const url_1 = require("url");
 const _ = require("lodash");
-let triggers;
+const types_1 = require("./types");
+const constants_1 = require("./constants");
+const functionsEmulatorShared_1 = require("./functionsEmulatorShared");
+const functionsEmulatorUtils_1 = require("./functionsEmulatorUtils");
+let functionModule;
+let FUNCTION_TARGET_NAME;
+let FUNCTION_SIGNATURE;
+let FUNCTION_DEBUG_MODE;
 let developerPkgJSON;
 const dynamicImport = new Function("modulePath", "return import(modulePath)");
 function isFeatureEnabled(frb, feature) {
@@ -112,7 +116,7 @@ async function resolveDeveloperNodeModule(frb, name) {
     if (!isInPackageJSON) {
         return { declared: false, installed: false };
     }
-    const resolveResult = await requireResolveAsync(name, { paths: [frb.cwd] }).catch(noOp);
+    const resolveResult = await requireResolveAsync(name, { paths: [process.cwd()] }).catch(noOp);
     if (!resolveResult) {
         return { declared: true, installed: false };
     }
@@ -160,7 +164,7 @@ function requirePackageJson(frb) {
         return developerPkgJSON;
     }
     try {
-        const pkg = require(`${frb.cwd}/package.json`);
+        const pkg = require(`${process.cwd()}/package.json`);
         developerPkgJSON = {
             engines: pkg.engines || {},
             dependencies: pkg.dependencies || {},
@@ -321,7 +325,7 @@ function getDefaultConfig() {
 }
 function initializeRuntimeConfig(frb) {
     if (!process.env.CLOUD_RUNTIME_CONFIG) {
-        const configPath = `${frb.cwd}/.runtimeconfig.json`;
+        const configPath = `${process.cwd()}/.runtimeconfig.json`;
         try {
             const configContent = fs.readFileSync(configPath, "utf8");
             if (configContent) {
@@ -359,7 +363,7 @@ async function initializeFirebaseAdminStubs(frb) {
         const defaultApp = makeProxiedFirebaseApp(frb, adminModuleTarget.initializeApp(defaultAppOptions));
         logDebug("initializeApp(DEFAULT)", defaultAppOptions);
         localFunctionsModule.app.setEmulatedAdminApp(defaultApp);
-        if (frb.emulators.auth) {
+        if (process.env[constants_1.Constants.FIREBASE_AUTH_EMULATOR_HOST]) {
             if ((0, functionsEmulatorUtils_1.compareVersionStrings)(adminResolution.version, "9.3.0") < 0) {
                 new types_1.EmulatorLog("WARN_ONCE", "runtime-status", "The Firebase Authentication emulator is running, but your 'firebase-admin' dependency is below version 9.3.0, so calls to Firebase Authentication will affect production.").log();
             }
@@ -377,16 +381,20 @@ async function initializeFirebaseAdminStubs(frb) {
         return defaultApp;
     })
         .when("firestore", (target) => {
-        warnAboutFirestoreProd(frb);
+        warnAboutFirestoreProd();
         return Proxied.getOriginal(target, "firestore");
     })
         .when("database", (target) => {
-        warnAboutDatabaseProd(frb);
+        warnAboutDatabaseProd();
         return Proxied.getOriginal(target, "database");
     })
         .when("auth", (target) => {
-        warnAboutAuthProd(frb);
+        warnAboutAuthProd();
         return Proxied.getOriginal(target, "auth");
+    })
+        .when("storage", (target) => {
+        warnAboutStorageProd();
+        return Proxied.getOriginal(target, "storage");
     })
         .finalize();
     require.cache[adminResolution.resolution] = Object.assign(require.cache[adminResolution.resolution], {
@@ -401,37 +409,47 @@ function makeProxiedFirebaseApp(frb, original) {
     const appProxy = new Proxied(original);
     return appProxy
         .when("firestore", (target) => {
-        warnAboutFirestoreProd(frb);
+        warnAboutFirestoreProd();
         return Proxied.getOriginal(target, "firestore");
     })
         .when("database", (target) => {
-        warnAboutDatabaseProd(frb);
+        warnAboutDatabaseProd();
         return Proxied.getOriginal(target, "database");
     })
         .when("auth", (target) => {
-        warnAboutAuthProd(frb);
+        warnAboutAuthProd();
         return Proxied.getOriginal(target, "auth");
+    })
+        .when("storage", (target) => {
+        warnAboutStorageProd();
+        return Proxied.getOriginal(target, "storage");
     })
         .finalize();
 }
-function warnAboutFirestoreProd(frb) {
-    if (frb.emulators.firestore) {
+function warnAboutFirestoreProd() {
+    if (process.env[constants_1.Constants.FIRESTORE_EMULATOR_HOST]) {
         return;
     }
     new types_1.EmulatorLog("WARN_ONCE", "runtime-status", "The Cloud Firestore emulator is not running, so calls to Firestore will affect production.").log();
 }
-function warnAboutDatabaseProd(frb) {
-    if (frb.emulators.database) {
+function warnAboutDatabaseProd() {
+    if (process.env[constants_1.Constants.FIREBASE_DATABASE_EMULATOR_HOST]) {
         return;
     }
     new types_1.EmulatorLog("WARN_ONCE", "runtime-status", "The Realtime Database emulator is not running, so calls to Realtime Database will affect production.").log();
 }
-function warnAboutAuthProd(frb) {
-    if (frb.emulators.auth) {
+function warnAboutAuthProd() {
+    if (process.env[constants_1.Constants.FIREBASE_AUTH_EMULATOR_HOST]) {
         return;
     }
     new types_1.EmulatorLog("WARN_ONCE", "runtime-status", "The Firebase Authentication emulator is not running, so calls to Firebase Authentication will affect production.").log();
 }
+function warnAboutStorageProd() {
+    if (process.env[constants_1.Constants.FIREBASE_STORAGE_EMULATOR_HOST]) {
+        return;
+    }
+    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");
     const localFunctionsModule = require(functionsResolution.resolution);
@@ -467,7 +485,7 @@ async function initializeFunctionsConfigHelper(frb) {
 function rawBodySaver(req, res, buf) {
     req.rawBody = buf;
 }
-async function processHTTPS(frb, trigger) {
+async function processHTTPS(trigger, frb) {
     const ephemeralServer = express();
     const functionRouter = express.Router();
     const socketPath = frb.socketPath;
@@ -479,7 +497,6 @@ async function processHTTPS(frb, trigger) {
         const handler = async (req, res) => {
             try {
                 logDebug(`Ephemeral server handling ${req.method} request`);
-                const func = trigger.getRawFunction();
                 res.on("finish", () => {
                     instance.close((err) => {
                         if (err) {
@@ -490,7 +507,7 @@ async function processHTTPS(frb, trigger) {
                         }
                     });
                 });
-                await runHTTPS([req, res], func);
+                await runHTTPS(trigger, [req, res]);
             }
             catch (err) {
                 rejectEphemeralServer(err);
@@ -524,11 +541,11 @@ async function processHTTPS(frb, trigger) {
         instance.on("error", rejectEphemeralServer);
     });
 }
-async function processBackground(frb, trigger, signature) {
+async function processBackground(trigger, frb, signature) {
     const proto = frb.proto;
     logDebug("ProcessBackground", proto);
     if (signature === "cloudevent") {
-        return runCloudEvent(proto, trigger.getRawFunction());
+        return runCloudEvent(trigger, proto);
     }
     const data = proto.data;
     delete proto.data;
@@ -539,7 +556,7 @@ async function processBackground(frb, trigger, signature) {
             context.resource = context.resource.name;
         }
     }
-    await runBackground({ data, context }, trigger.getRawFunction());
+    await runBackground(trigger, { data, context });
 }
 async function runFunction(func) {
     let caughtErr;
@@ -554,30 +571,30 @@ async function runFunction(func) {
         throw caughtErr;
     }
 }
-async function runBackground(proto, func) {
+async function runBackground(trigger, proto) {
     logDebug("RunBackground", proto);
     await runFunction(() => {
-        return func(proto.data, proto.context);
+        return trigger(proto.data, proto.context);
     });
 }
-async function runCloudEvent(event, func) {
+async function runCloudEvent(trigger, event) {
     logDebug("RunCloudEvent", event);
     await runFunction(() => {
-        return func(event);
+        return trigger(event);
     });
 }
-async function runHTTPS(args, func) {
+async function runHTTPS(trigger, args) {
     if (args.length < 2) {
         throw new Error("Function must be passed 2 args.");
     }
     await runFunction(() => {
-        return func(args[0], args[1]);
+        return trigger(args[0], args[1]);
     });
 }
 async function moduleResolutionDetective(frb, error) {
     const clues = {
-        tsconfigJSON: await requireAsync("./tsconfig.json", { paths: [frb.cwd] }).catch(noOp),
-        packageJSON: await requireAsync("./package.json", { paths: [frb.cwd] }).catch(noOp),
+        tsconfigJSON: await requireAsync("./tsconfig.json", { paths: [process.cwd()] }).catch(noOp),
+        packageJSON: await requireAsync("./package.json", { paths: [process.cwd()] }).catch(noOp),
     };
     const isPotentially = {
         typescript: false,
@@ -595,45 +612,57 @@ async function moduleResolutionDetective(frb, error) {
 function logDebug(msg, data) {
     new types_1.EmulatorLog("DEBUG", "runtime-status", `[${process.pid}] ${msg}`, data).log();
 }
-async function invokeTrigger(frb, triggers) {
-    if (!frb.triggerId) {
-        throw new Error("frb.triggerId unexpectedly null");
-    }
-    new types_1.EmulatorLog("INFO", "runtime-status", `Beginning execution of "${frb.triggerId}"`, {
+async function invokeTrigger(trigger, frb) {
+    new types_1.EmulatorLog("INFO", "runtime-status", `Beginning execution of "${FUNCTION_TARGET_NAME}"`, {
         frb,
     }).log();
-    const trigger = triggers[frb.triggerId];
-    logDebug("triggerDefinition", trigger.definition);
-    const signature = (0, functionsEmulatorShared_1.getSignatureType)(trigger.definition);
-    logDebug(`Running ${frb.triggerId} in signature ${signature}`);
+    logDebug(`Running ${FUNCTION_TARGET_NAME} in signature ${FUNCTION_SIGNATURE}`);
     let seconds = 0;
     const timerId = setInterval(() => {
         seconds++;
     }, 1000);
     let timeoutId;
     if (isFeatureEnabled(frb, "timeout")) {
+        let timeout = process.env.FUNCTIONS_EMULATOR_TIMEOUT_SECONDS || "60";
+        if (timeout.endsWith("s")) {
+            timeout = timeout.slice(0, -1);
+        }
+        const timeoutMs = parseInt(timeout, 10) * 1000;
         timeoutId = setTimeout(() => {
-            new types_1.EmulatorLog("WARN", "runtime-status", `Your function timed out after ~${trigger.definition.timeout || "60s"}. To configure this timeout, see
+            new types_1.EmulatorLog("WARN", "runtime-status", `Your function timed out after ~${timeout}s. To configure this timeout, see
       https://firebase.google.com/docs/functions/manage-functions#set_timeout_and_memory_allocation.`).log();
             throw new Error("Function timed out.");
-        }, trigger.timeoutMs);
+        }, timeoutMs);
     }
-    switch (signature) {
+    switch (FUNCTION_SIGNATURE) {
         case "event":
         case "cloudevent":
-            await processBackground(frb, triggers[frb.triggerId], signature);
+            await processBackground(trigger, frb, FUNCTION_SIGNATURE);
             break;
         case "http":
-            await processHTTPS(frb, triggers[frb.triggerId]);
+            await processHTTPS(trigger, frb);
             break;
     }
     if (timeoutId) {
         clearTimeout(timeoutId);
     }
     clearInterval(timerId);
-    new types_1.EmulatorLog("INFO", "runtime-status", `Finished "${frb.triggerId}" in ~${Math.max(seconds, 1)}s`).log();
-}
-async function initializeRuntime(frb, serializedFunctionTrigger, extensionTriggers) {
+    new types_1.EmulatorLog("INFO", "runtime-status", `Finished "${FUNCTION_TARGET_NAME}" in ~${Math.max(seconds, 1)}s`).log();
+}
+async function initializeRuntime(frb) {
+    FUNCTION_DEBUG_MODE = process.env.FUNCTION_DEBUG_MODE || "";
+    if (!FUNCTION_DEBUG_MODE) {
+        FUNCTION_TARGET_NAME = process.env.FUNCTION_TARGET || "";
+        if (!FUNCTION_TARGET_NAME) {
+            new types_1.EmulatorLog("FATAL", "runtime-status", `Environment variable FUNCTION_TARGET cannot be empty. This shouldn't happen.`).log();
+            await flushAndExit(1);
+        }
+        FUNCTION_SIGNATURE = process.env.FUNCTION_SIGNATURE_TYPE || "";
+        if (!FUNCTION_SIGNATURE) {
+            new types_1.EmulatorLog("FATAL", "runtime-status", `Environment variable FUNCTION_SIGNATURE_TYPE cannot be empty. This shouldn't happen.`).log();
+            await flushAndExit(1);
+        }
+    }
     logDebug(`Disabled runtime features: ${JSON.stringify(frb.disabled_features)}`);
     const verified = await verifyDeveloperNodeModules(frb);
     if (!verified) {
@@ -645,35 +674,27 @@ async function initializeRuntime(frb, serializedFunctionTrigger, extensionTrigge
     await initializeFunctionsConfigHelper(frb);
     await initializeFirebaseFunctionsStubs(frb);
     await initializeFirebaseAdminStubs(frb);
-    let parsedDefinitions = [];
+}
+async function loadTriggers(frb, serializedFunctionTrigger) {
     let triggerModule;
     if (serializedFunctionTrigger) {
         triggerModule = eval(serializedFunctionTrigger)();
     }
     else {
         try {
-            triggerModule = require(frb.cwd);
+            triggerModule = require(process.cwd());
         }
         catch (err) {
             if (err.code !== "ERR_REQUIRE_ESM") {
                 await moduleResolutionDetective(frb, err);
-                return;
+                throw err;
             }
-            const modulePath = require.resolve(frb.cwd);
+            const modulePath = require.resolve(process.cwd());
             const moduleURL = (0, url_1.pathToFileURL)(modulePath).href;
             triggerModule = await dynamicImport(moduleURL);
         }
     }
-    if (extensionTriggers) {
-        parsedDefinitions = extensionTriggers;
-    }
-    else {
-        require("../deploy/functions/runtimes/node/extractTriggers")(triggerModule, parsedDefinitions);
-    }
-    const triggerDefinitions = (0, functionsEmulatorShared_1.emulatedFunctionsByRegion)(parsedDefinitions);
-    const triggers = (0, functionsEmulatorShared_1.getEmulatedTriggersFromDefinitions)(triggerDefinitions, triggerModule);
-    new types_1.EmulatorLog("SYSTEM", "triggers-parsed", "", { triggers, triggerDefinitions }).log();
-    return triggers;
+    return triggerModule;
 }
 async function flushAndExit(code) {
     await types_1.EmulatorLog.waitForFlush();
@@ -693,28 +714,32 @@ async function handleMessage(message) {
         await flushAndExit(1);
         return;
     }
-    if (!triggers) {
-        const serializedTriggers = runtimeArgs.opts ? runtimeArgs.opts.serializedTriggers : undefined;
-        const extensionTriggers = runtimeArgs.opts ? runtimeArgs.opts.extensionTriggers : undefined;
-        triggers = await initializeRuntime(runtimeArgs.frb, serializedTriggers, extensionTriggers);
-    }
-    if (!triggers) {
-        await flushAndExit(1);
-        return;
-    }
-    if (!runtimeArgs.frb.triggerId) {
-        await goIdle();
-        return;
+    if (!functionModule) {
+        try {
+            await initializeRuntime(runtimeArgs.frb);
+            const serializedTriggers = runtimeArgs.opts ? runtimeArgs.opts.serializedTriggers : undefined;
+            functionModule = await loadTriggers(runtimeArgs.frb, serializedTriggers);
+        }
+        catch (e) {
+            logDebug(e);
+            new types_1.EmulatorLog("FATAL", "runtime-status", `Failed to initialize and load triggers. This shouldn't happen: ${e.message}`).log();
+            await flushAndExit(1);
+            return;
+        }
     }
-    if (!triggers[runtimeArgs.frb.triggerId]) {
-        new types_1.EmulatorLog("FATAL", "runtime-status", `Could not find trigger "${runtimeArgs.frb.triggerId}" in your functions directory.`).log();
-        return;
+    if (FUNCTION_DEBUG_MODE) {
+        FUNCTION_TARGET_NAME = runtimeArgs.frb.debug.functionTarget;
+        FUNCTION_SIGNATURE = runtimeArgs.frb.debug.functionSignature;
     }
-    else {
-        logDebug(`Trigger "${runtimeArgs.frb.triggerId}" has been found, beginning invocation!`);
+    const trigger = FUNCTION_TARGET_NAME.split(".").reduce((mod, functionTargetPart) => {
+        return mod === null || mod === void 0 ? void 0 : mod[functionTargetPart];
+    }, functionModule);
+    if (!trigger) {
+        throw new Error(`Failed to find function ${FUNCTION_TARGET_NAME} in the loaded module`);
     }
+    logDebug(`Beginning invocation function ${FUNCTION_TARGET_NAME}!`);
     try {
-        await invokeTrigger(runtimeArgs.frb, triggers);
+        await invokeTrigger(trigger, runtimeArgs.frb);
         if (runtimeArgs.opts && runtimeArgs.opts.serializedTriggers) {
             await flushAndExit(0);
         }

package/lib/emulator/functionsEmulatorShared.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSignatureType = exports.formatHost = exports.findModuleRoot = exports.waitForBody = exports.getServiceFromEventType = exports.getFunctionService = exports.getTemporarySocketPath = exports.getEmulatedTriggersFromDefinitions = exports.emulatedFunctionsByRegion = exports.EmulatedTrigger = exports.HttpConstants = void 0;
+exports.getSignatureType = exports.formatHost = exports.findModuleRoot = exports.waitForBody = exports.getServiceFromEventType = exports.getFunctionService = exports.getTemporarySocketPath = exports.getEmulatedTriggersFromDefinitions = exports.emulatedFunctionsByRegion = exports.emulatedFunctionsFromEndpoints = exports.EmulatedTrigger = exports.HttpConstants = void 0;
 const _ = require("lodash");
 const os = require("os");
 const path = require("path");
 const fs = require("fs");
 const constants_1 = require("./constants");
+const backend_1 = require("../deploy/functions/backend");
+const proto_1 = require("../gcp/proto");
 const memoryLookup = {
     "128MB": 128,
     "256MB": 256,
@@ -44,6 +46,54 @@ class EmulatedTrigger {
     }
 }
 exports.EmulatedTrigger = EmulatedTrigger;
+function emulatedFunctionsFromEndpoints(endpoints) {
+    const regionDefinitions = [];
+    for (const endpoint of endpoints) {
+        if (!endpoint.region) {
+            endpoint.region = "us-central1";
+        }
+        const def = {
+            entryPoint: endpoint.entryPoint,
+            platform: endpoint.platform,
+            region: endpoint.region,
+            name: endpoint.id,
+            id: `${endpoint.region}-${endpoint.id}`,
+        };
+        (0, proto_1.copyIfPresent)(def, endpoint, "timeout", "availableMemoryMb", "labels", "platform", "secretEnvironmentVariables");
+        if ((0, backend_1.isHttpsTriggered)(endpoint)) {
+            def.httpsTrigger = endpoint.httpsTrigger;
+        }
+        else if ((0, backend_1.isEventTriggered)(endpoint)) {
+            const eventTrigger = endpoint.eventTrigger;
+            if (endpoint.platform === "gcfv1") {
+                def.eventTrigger = {
+                    eventType: eventTrigger.eventType,
+                    resource: eventTrigger.eventFilters.resource,
+                };
+            }
+            else {
+                const { resource, topic, bucket } = endpoint.eventTrigger.eventFilters;
+                const eventResource = resource || topic || bucket;
+                if (!eventResource) {
+                    continue;
+                }
+                def.eventTrigger = {
+                    eventType: eventTrigger.eventType,
+                    resource: eventResource,
+                };
+            }
+        }
+        else if ((0, backend_1.isScheduleTriggered)(endpoint)) {
+            def.eventTrigger = { eventType: "pubsub", resource: "" };
+            def.schedule = endpoint.scheduleTrigger;
+        }
+        else {
+        }
+        regionDefinitions.push(def);
+    }
+    return regionDefinitions;
+}
+exports.emulatedFunctionsFromEndpoints = emulatedFunctionsFromEndpoints;
 function emulatedFunctionsByRegion(definitions) {
     const regionDefinitions = [];
     for (const def of definitions) {

package/lib/emulator/functionsEmulatorShell.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FunctionsEmulatorShell = void 0;
 const uuid = require("uuid");
 const functionsEmulator_1 = require("./functionsEmulator");
-const functionsEmulatorShared_1 = require("./functionsEmulatorShared");
 const utils = require("../utils");
 const logger_1 = require("../logger");
 const error_1 = require("../error");
@@ -43,7 +42,7 @@ class FunctionsEmulatorShell {
             auth: opts.auth,
             data,
         };
-        this.emu.startFunctionRuntime(this.backend, trigger.id, trigger.name, (0, functionsEmulatorShared_1.getSignatureType)(trigger), proto);
+        this.emu.invokeTrigger(this.backend, trigger, proto);
     }
     getTrigger(name) {
         const result = this.triggers.find((trigger) => {

package/lib/emulator/functionsEmulatorUtils.js

@@ -52,7 +52,7 @@ function parseRuntimeVersion(runtime) {
         return undefined;
     }
     const runtimeRe = /(nodejs)?([0-9]+)/;
-    const match = runtime.match(runtimeRe);
+    const match = runtimeRe.exec(runtime);
     if (match) {
         return Number.parseInt(match[2]);
     }
@@ -73,13 +73,13 @@ exports.parseVersionString = parseVersionString;
 function compareVersionStrings(a, b) {
     const versionA = parseVersionString(a);
     const versionB = parseVersionString(b);
-    if (versionA.major != versionB.major) {
+    if (versionA.major !== versionB.major) {
         return versionA.major - versionB.major;
     }
-    if (versionA.minor != versionB.minor) {
+    if (versionA.minor !== versionB.minor) {
         return versionA.minor - versionB.minor;
     }
-    if (versionA.patch != versionB.patch) {
+    if (versionA.patch !== versionB.patch) {
         return versionA.patch - versionB.patch;
     }
     return 0;

package/lib/emulator/functionsRuntimeWorker.js

@@ -43,7 +43,7 @@ class RuntimeWorker {
     execute(frb, opts) {
         const execFrb = Object.assign({}, frb);
         if (!execFrb.socketPath) {
-            execFrb.socketPath = (0, functionsEmulatorShared_1.getTemporarySocketPath)(this.runtime.pid, execFrb.cwd);
+            execFrb.socketPath = (0, functionsEmulatorShared_1.getTemporarySocketPath)(this.runtime.pid, this.runtime.cwd);
             this.log(`Assigning socketPath: ${execFrb.socketPath}`);
         }
         const args = { frb: execFrb, opts };
@@ -170,14 +170,14 @@ class RuntimeWorkerPool {
         }
         return;
     }
-    addWorker(triggerId, runtime) {
+    addWorker(triggerId, runtime, extensionLogInfo) {
         const worker = new RuntimeWorker(this.getKey(triggerId), runtime);
         this.log(`addWorker(${worker.key})`);
         const keyWorkers = this.getTriggerWorkers(triggerId);
         keyWorkers.push(worker);
         this.setTriggerWorkers(triggerId, keyWorkers);
         const logger = triggerId
-            ? emulatorLogger_1.EmulatorLogger.forFunction(triggerId)
+            ? emulatorLogger_1.EmulatorLogger.forFunction(triggerId, extensionLogInfo)
             : emulatorLogger_1.EmulatorLogger.forEmulator(types_1.Emulators.FUNCTIONS);
         worker.onLogs((log) => {
             logger.handleRuntimeLog(log);

package/lib/emulator/hub.js

@@ -25,9 +25,10 @@ class EmulatorHub {
         });
         this.hub.get(EmulatorHub.PATH_EMULATORS, (req, res) => {
             const body = {};
-            registry_1.EmulatorRegistry.listRunning().forEach((name) => {
-                body[name] = registry_1.EmulatorRegistry.get(name).getInfo();
-            });
+            for (const emulator of registry_1.EmulatorRegistry.listRunning()) {
+                const info = registry_1.EmulatorRegistry.getInfo(emulator);
+                body[emulator] = info;
+            }
             res.json(body);
         });
         this.hub.post(EmulatorHub.PATH_EXPORT, async (req, res) => {

package/lib/emulator/loggingEmulator.js

@@ -82,7 +82,7 @@ class WebSocketTransport extends TransportStream {
         };
         const splat = [info.message, ...(info[triple_beam_1.SPLAT] || [])]
             .map((value) => {
-            if (typeof value == "string") {
+            if (typeof value === "string") {
                 try {
                     bundle.data = Object.assign(Object.assign({}, bundle.data), JSON.parse(value));
                     return null;

package/lib/emulator/pubsubEmulator.js

@@ -88,7 +88,7 @@ class PubsubEmulator {
         this.subscriptionForTopic.set(topicName, sub);
     }
     ensureFunctionsClient() {
-        if (this.client != undefined)
+        if (this.client !== undefined)
             return;
         const funcEmulator = registry_1.EmulatorRegistry.get(types_1.Emulators.FUNCTIONS);
         if (!funcEmulator) {

package/lib/emulator/registry.js

@@ -17,6 +17,9 @@ class EmulatorRegistry {
         const info = instance.getInfo();
         await portUtils.waitForPortClosed(info.port, info.host);
     }
+    static registerExtensionsEmulator() {
+        this.extensionsEmulatorRegistered = true;
+    }
     static async stop(name) {
         emulatorLogger_1.EmulatorLogger.forEmulator(name).logLabeled("BULLET", name, `Stopping ${constants_1.Constants.description(name)}`);
         const instance = this.get(name);
@@ -29,7 +32,8 @@ class EmulatorRegistry {
     static async stopAll() {
         const stopPriority = {
             ui: 0,
-            functions: 1,
+            extensions: 1,
+            functions: 1.1,
             hosting: 2,
             database: 3.0,
             firestore: 3.1,
@@ -52,6 +56,9 @@ class EmulatorRegistry {
         }
     }
     static isRunning(emulator) {
+        if (emulator === types_1.Emulators.EXTENSIONS) {
+            return this.extensionsEmulatorRegistered && this.isRunning(types_1.Emulators.FUNCTIONS);
+        }
         const instance = this.INSTANCES.get(emulator);
         return instance !== undefined;
     }
@@ -67,7 +74,7 @@ class EmulatorRegistry {
         return this.INSTANCES.get(emulator);
     }
     static getInfo(emulator) {
-        const instance = this.INSTANCES.get(emulator);
+        const instance = this.INSTANCES.get(emulator === types_1.Emulators.EXTENSIONS ? types_1.Emulators.FUNCTIONS : emulator);
         if (!instance) {
             return undefined;
         }
@@ -97,4 +104,5 @@ class EmulatorRegistry {
     }
 }
 exports.EmulatorRegistry = EmulatorRegistry;
+EmulatorRegistry.extensionsEmulatorRegistered = false;
 EmulatorRegistry.INSTANCES = new Map();