firebase-tools 11.14.1 → 11.14.2

package/lib/emulator/controller.js

@@ -27,7 +27,6 @@ const ui_1 = require("./ui");
 const loggingEmulator_1 = require("./loggingEmulator");
 const dbRulesConfig = require("../database/rulesConfig");
 const emulatorLogger_1 = require("./emulatorLogger");
-const portUtils = require("./portUtils");
 const hubClient_1 = require("./hubClient");
 const prompt_1 = require("../prompt");
 const commandUtils_1 = require("./commandUtils");
@@ -41,87 +40,8 @@ const projectConfig_1 = require("../functions/projectConfig");
 const downloadableEmulators_1 = require("./downloadableEmulators");
 const frameworks_1 = require("../frameworks");
 const experiments = require("../experiments");
+const portUtils_1 = require("./portUtils");
 const START_LOGGING_EMULATOR = utils.envOverride("START_LOGGING_EMULATOR", "false", (val) => val === "true");
-async function getAndCheckAddress(emulator, options) {
-    var _a, _b, _c, _d;
-    if (emulator === types_1.Emulators.EXTENSIONS) {
-        emulator = types_1.Emulators.FUNCTIONS;
-    }
-    let host = ((_b = (_a = options.config.src.emulators) === null || _a === void 0 ? void 0 : _a[emulator]) === null || _b === void 0 ? void 0 : _b.host) || constants_1.Constants.getDefaultHost();
-    if (host === "localhost" && utils.isRunningInWSL()) {
-        host = "127.0.0.1";
-    }
-    const portVal = (_d = (_c = options.config.src.emulators) === null || _c === void 0 ? void 0 : _c[emulator]) === null || _d === void 0 ? void 0 : _d.port;
-    let port;
-    let findAvailablePort = false;
-    if (portVal) {
-        port = parseInt(`${portVal}`, 10);
-    }
-    else {
-        port = constants_1.Constants.getDefaultPort(emulator);
-        findAvailablePort = constants_1.FIND_AVAILBLE_PORT_BY_DEFAULT[emulator];
-    }
-    const loggerForEmulator = emulatorLogger_1.EmulatorLogger.forEmulator(emulator);
-    const portOpen = await portUtils.checkPortOpen(port, host);
-    if (!portOpen) {
-        if (findAvailablePort) {
-            const newPort = await portUtils.findAvailablePort(host, port);
-            if (newPort !== port) {
-                loggerForEmulator.logLabeled("WARN", emulator, `${constants_1.Constants.description(emulator)} unable to start on port ${port}, starting on ${newPort} instead.`);
-                port = newPort;
-            }
-        }
-        else {
-            await cleanShutdown();
-            const description = constants_1.Constants.description(emulator);
-            loggerForEmulator.logLabeled("WARN", emulator, `Port ${port} is not open on ${host}, could not start ${description}.`);
-            loggerForEmulator.logLabeled("WARN", emulator, `To select a different host/port, specify that host/port in a firebase.json config file:
-      {
-        // ...
-        "emulators": {
-          "${emulator}": {
-            "host": "${clc.yellow("HOST")}",
-            "port": "${clc.yellow("PORT")}"
-          }
-        }
-      }`);
-            return utils.reject(`Could not start ${description}, port taken.`, {});
-        }
-    }
-    if (portUtils.isRestricted(port)) {
-        const suggested = portUtils.suggestUnrestricted(port);
-        loggerForEmulator.logLabeled("WARN", emulator, `Port ${port} is restricted by some web browsers, including Chrome. You may want to choose a different port such as ${suggested}.`);
-    }
-    return { host, port };
-}
-async function getFirestoreWebSocketPort(host, port, emulator) {
-    let websocketPort;
-    if (port) {
-        const portOpen = await portUtils.checkPortOpen(port, host);
-        if (!portOpen) {
-            await cleanShutdown();
-            const logger = emulatorLogger_1.EmulatorLogger.forEmulator(emulator);
-            logger.logLabeled("WARN", emulator, `Port ${port} is not open on ${host}, could not start websocket server for Firestore emulator.`);
-            logger.logLabeled("WARN", emulator, `To select a different port, specify that port in a firebase.json config file:
-      {
-        // ...
-        "emulators": {
-          "${emulator}": {
-            "host": "${clc.yellow("HOST")}",
-            ...
-            "websocketPort": "${clc.yellow("WEBSOCKET_PORT")}"
-          }
-        }
-      }`);
-            return utils.reject(`Could not start websocket, port taken.`, {});
-        }
-        websocketPort = port;
-    }
-    else {
-        websocketPort = await portUtils.findAvailablePort(host, 9150);
-    }
-    return websocketPort;
-}
 async function exportOnExit(options) {
     const exportOnExitDir = options.exportOnExit;
     if (exportOnExitDir) {
@@ -232,7 +152,7 @@ function findExportMetadata(importPath) {
     }
 }
 async function startAll(options, showUI = true) {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c, _d, _e, _f, _g;
     const targets = filterEmulatorTargets(options);
     options.targets = targets;
     const singleProjectModeEnabled = ((_a = options.config.src.emulators) === null || _a === void 0 ? void 0 : _a.singleProjectMode) === undefined ||
@@ -268,6 +188,60 @@ async function startAll(options, showUI = true) {
             }
         }
     }
+    const emulatableBackends = [];
+    let extensionEmulator = undefined;
+    if (shouldStart(options, types_1.Emulators.EXTENSIONS)) {
+        const projectNumber = isDemoProject
+            ? constants_1.Constants.FAKE_PROJECT_NUMBER
+            : await (0, projectUtils_1.needProjectNumber)(options);
+        const aliases = (0, projectUtils_1.getAliases)(options, projectId);
+        extensionEmulator = new extensionsEmulator_1.ExtensionsEmulator({
+            projectId,
+            projectDir: options.config.projectDir,
+            projectNumber,
+            aliases,
+            extensions: options.config.get("extensions"),
+        });
+        const extensionsBackends = await extensionEmulator.getExtensionBackends();
+        const filteredExtensionsBackends = extensionEmulator.filterUnemulatedTriggers(options, extensionsBackends);
+        emulatableBackends.push(...filteredExtensionsBackends);
+    }
+    const listenConfig = {};
+    if (emulatableBackends.length) {
+        listenConfig[types_1.Emulators.FUNCTIONS] = getListenConfig(options, types_1.Emulators.FUNCTIONS);
+        listenConfig[types_1.Emulators.EVENTARC] = getListenConfig(options, types_1.Emulators.EVENTARC);
+    }
+    for (const emulator of types_1.ALL_EMULATORS) {
+        if (emulator === types_1.Emulators.FUNCTIONS ||
+            emulator === types_1.Emulators.EVENTARC ||
+            emulator === types_1.Emulators.EXTENSIONS ||
+            (emulator === types_1.Emulators.UI && !showUI)) {
+            continue;
+        }
+        if (shouldStart(options, emulator) ||
+            (emulator === types_1.Emulators.LOGGING &&
+                ((showUI && shouldStart(options, types_1.Emulators.UI)) || START_LOGGING_EMULATOR))) {
+            const config = getListenConfig(options, emulator);
+            listenConfig[emulator] = config;
+            if (emulator === types_1.Emulators.FIRESTORE) {
+                const wsPortConfig = (_d = (_c = options.config.src.emulators) === null || _c === void 0 ? void 0 : _c.firestore) === null || _d === void 0 ? void 0 : _d.websocketPort;
+                listenConfig["firestore.websocket"] = {
+                    host: config.host,
+                    port: wsPortConfig || 9150,
+                    portFixed: !!wsPortConfig,
+                };
+            }
+        }
+    }
+    let listenForEmulator = await (0, portUtils_1.resolveHostAndAssignPorts)(listenConfig);
+    hubLogger.log("DEBUG", "assigned listening specs for emulators", { user: listenForEmulator });
+    function legacyGetFirstAddr(name) {
+        const firstSpec = listenForEmulator[name][0];
+        return {
+            host: firstSpec.address,
+            port: firstSpec.port,
+        };
+    }
     function startEmulator(instance) {
         const name = instance.getName();
         void (0, track_1.track)("Emulator Run", name);
@@ -277,9 +251,12 @@ async function startAll(options, showUI = true) {
         });
         return registry_1.EmulatorRegistry.start(instance);
     }
-    if (shouldStart(options, types_1.Emulators.HUB)) {
-        const hubAddr = await getAndCheckAddress(types_1.Emulators.HUB, options);
-        const hub = new hub_1.EmulatorHub(Object.assign({ projectId }, hubAddr));
+    if (listenForEmulator.hub) {
+        const hub = new hub_1.EmulatorHub({
+            projectId,
+            listen: listenForEmulator[types_1.Emulators.HUB],
+            listenForEmulator,
+        });
         void (0, track_1.track)("emulators:start", "hub");
         await startEmulator(hub);
     }
@@ -306,15 +283,18 @@ async function startAll(options, showUI = true) {
         experiments.assertEnabled("webframeworks", "emulate a web framework");
         const emulators = [];
         if (experiments.isEnabled("webframeworks")) {
-            for (const e of types_1.EMULATORS_SUPPORTED_BY_UI) {
-                const info = registry_1.EmulatorRegistry.getInfo(e);
-                if (info)
-                    emulators.push(info);
+            for (const e of types_1.ALL_SERVICE_EMULATORS) {
+                if (listenForEmulator[e]) {
+                    emulators.push({
+                        name: e,
+                        host: utils.connectableHostname(listenForEmulator[e][0].address),
+                        port: listenForEmulator[e][0].port,
+                    });
+                }
             }
         }
         await (0, frameworks_1.prepareFrameworks)(targets, options, options, emulators);
     }
-    const emulatableBackends = [];
     const projectDir = (options.extDevDir || options.config.projectDir);
     if (shouldStart(options, types_1.Emulators.FUNCTIONS)) {
         const functionsCfg = (0, projectConfig_1.normalizeAndValidate)(options.config.src.functions);
@@ -331,26 +311,18 @@ async function startAll(options, showUI = true) {
             });
         }
     }
-    if (shouldStart(options, types_1.Emulators.EXTENSIONS)) {
-        const projectNumber = isDemoProject
-            ? constants_1.Constants.FAKE_PROJECT_NUMBER
-            : await (0, projectUtils_1.needProjectNumber)(options);
-        const aliases = (0, projectUtils_1.getAliases)(options, projectId);
-        const extensionEmulator = new extensionsEmulator_1.ExtensionsEmulator({
-            projectId,
-            projectDir: options.config.projectDir,
-            projectNumber,
-            aliases,
-            extensions: options.config.get("extensions"),
-        });
-        const extensionsBackends = await extensionEmulator.getExtensionBackends();
-        const filteredExtensionsBackends = extensionEmulator.filterUnemulatedTriggers(options, extensionsBackends);
-        emulatableBackends.push(...filteredExtensionsBackends);
+    if (extensionEmulator) {
         await startEmulator(extensionEmulator);
     }
     if (emulatableBackends.length) {
+        if (!listenForEmulator.functions || !listenForEmulator.eventarc) {
+            listenForEmulator = await (0, portUtils_1.resolveHostAndAssignPorts)(Object.assign(Object.assign({}, listenForEmulator), { functions: (_e = listenForEmulator.functions) !== null && _e !== void 0 ? _e : getListenConfig(options, types_1.Emulators.FUNCTIONS), eventarc: (_f = listenForEmulator.eventarc) !== null && _f !== void 0 ? _f : getListenConfig(options, types_1.Emulators.EVENTARC) }));
+            hubLogger.log("DEBUG", "late-assigned ports for functions and eventarc emulators", {
+                user: listenForEmulator,
+            });
+        }
         const functionsLogger = emulatorLogger_1.EmulatorLogger.forEmulator(types_1.Emulators.FUNCTIONS);
-        const functionsAddr = await getAndCheckAddress(types_1.Emulators.FUNCTIONS, options);
+        const functionsAddr = legacyGetFirstAddr(types_1.Emulators.FUNCTIONS);
         const projectId = (0, projectUtils_1.needProjectId)(options);
         let inspectFunctions;
         if (options.inspectFunctions) {
@@ -358,7 +330,7 @@ async function startAll(options, showUI = true) {
             functionsLogger.logLabeled("WARN", "functions", `You are running the Functions emulator in debug mode (port=${inspectFunctions}). This means that functions will execute in sequence rather than in parallel.`);
         }
         const emulatorsNotRunning = types_1.ALL_SERVICE_EMULATORS.filter((e) => {
-            return e !== types_1.Emulators.FUNCTIONS && !shouldStart(options, e);
+            return e !== types_1.Emulators.FUNCTIONS && !listenForEmulator[e];
         });
         if (emulatorsNotRunning.length > 0 && !constants_1.Constants.isDemoProject(projectId)) {
             functionsLogger.logLabeled("WARN", "functions", `The following emulators are not running, calls to these services from the Functions emulator will affect production: ${clc.bold(emulatorsNotRunning.join(", "))}`);
@@ -375,18 +347,17 @@ async function startAll(options, showUI = true) {
             projectAlias: options.projectAlias,
         });
         await startEmulator(functionsEmulator);
-        const eventarcAddr = await getAndCheckAddress(types_1.Emulators.EVENTARC, options);
+        const eventarcAddr = legacyGetFirstAddr(types_1.Emulators.EVENTARC);
         const eventarcEmulator = new eventarcEmulator_1.EventarcEmulator({
             host: eventarcAddr.host,
             port: eventarcAddr.port,
         });
         await startEmulator(eventarcEmulator);
     }
-    if (shouldStart(options, types_1.Emulators.FIRESTORE)) {
+    if (listenForEmulator.firestore) {
         const firestoreLogger = emulatorLogger_1.EmulatorLogger.forEmulator(types_1.Emulators.FIRESTORE);
-        const firestoreAddr = await getAndCheckAddress(types_1.Emulators.FIRESTORE, options);
-        const portVal = (_d = (_c = options.config.src.emulators) === null || _c === void 0 ? void 0 : _c.firestore) === null || _d === void 0 ? void 0 : _d.websocketPort;
-        const websocketPort = await getFirestoreWebSocketPort(firestoreAddr.host, portVal, types_1.Emulators.FIRESTORE);
+        const firestoreAddr = legacyGetFirstAddr(types_1.Emulators.FIRESTORE);
+        const websocketPort = legacyGetFirstAddr("firestore.websocket").port;
         const args = {
             host: firestoreAddr.host,
             port: firestoreAddr.port,
@@ -406,7 +377,7 @@ async function startAll(options, showUI = true) {
             });
         }
         const config = options.config;
-        const rulesLocalPath = (_e = config.src.firestore) === null || _e === void 0 ? void 0 : _e.rules;
+        const rulesLocalPath = (_g = config.src.firestore) === null || _g === void 0 ? void 0 : _g.rules;
         let rulesFileFound = false;
         if (rulesLocalPath) {
             const rules = config.path(rulesLocalPath);
@@ -437,14 +408,15 @@ async function startAll(options, showUI = true) {
         await startEmulator(firestoreEmulator);
         firestoreLogger.logLabeled("SUCCESS", types_1.Emulators.FIRESTORE, `Firestore Emulator UI websocket is running on ${websocketPort}.`);
     }
-    if (shouldStart(options, types_1.Emulators.DATABASE)) {
+    if (listenForEmulator.database) {
         const databaseLogger = emulatorLogger_1.EmulatorLogger.forEmulator(types_1.Emulators.DATABASE);
-        const databaseAddr = await getAndCheckAddress(types_1.Emulators.DATABASE, options);
+        const databaseAddr = legacyGetFirstAddr(types_1.Emulators.DATABASE);
         const args = {
             host: databaseAddr.host,
             port: databaseAddr.port,
             projectId,
             auto_download: true,
+            single_project_mode: singleProjectModeEnabled ? "Warning" : undefined,
         };
         try {
             if (!options.instance) {
@@ -487,11 +459,11 @@ async function startAll(options, showUI = true) {
             }
         }
     }
-    if (shouldStart(options, types_1.Emulators.AUTH)) {
+    if (listenForEmulator.auth) {
         if (!projectId) {
             throw new error_1.FirebaseError(`Cannot start the ${constants_1.Constants.description(types_1.Emulators.AUTH)} without a project: run 'firebase init' or provide the --project flag`);
         }
-        const authAddr = await getAndCheckAddress(types_1.Emulators.AUTH, options);
+        const authAddr = legacyGetFirstAddr(types_1.Emulators.AUTH);
         const authEmulator = new auth_1.AuthEmulator({
             host: authAddr.host,
             port: authAddr.port,
@@ -508,11 +480,11 @@ async function startAll(options, showUI = true) {
             await authEmulator.importData(authExportDir, projectId, { initiatedBy: "start" });
         }
     }
-    if (shouldStart(options, types_1.Emulators.PUBSUB)) {
+    if (listenForEmulator.pubsub) {
         if (!projectId) {
             throw new error_1.FirebaseError("Cannot start the Pub/Sub emulator without a project: run 'firebase init' or provide the --project flag");
         }
-        const pubsubAddr = await getAndCheckAddress(types_1.Emulators.PUBSUB, options);
+        const pubsubAddr = legacyGetFirstAddr(types_1.Emulators.PUBSUB);
         const pubsubEmulator = new pubsubEmulator_1.PubsubEmulator({
             host: pubsubAddr.host,
             port: pubsubAddr.port,
@@ -521,8 +493,8 @@ async function startAll(options, showUI = true) {
         });
         await startEmulator(pubsubEmulator);
     }
-    if (shouldStart(options, types_1.Emulators.STORAGE)) {
-        const storageAddr = await getAndCheckAddress(types_1.Emulators.STORAGE, options);
+    if (listenForEmulator.storage) {
+        const storageAddr = legacyGetFirstAddr(types_1.Emulators.STORAGE);
         const storageEmulator = new storage_1.StorageEmulator({
             host: storageAddr.host,
             port: storageAddr.port,
@@ -537,8 +509,8 @@ async function startAll(options, showUI = true) {
             storageEmulator.storageLayer.import(storageExportDir, { initiatedBy: "start" });
         }
     }
-    if (shouldStart(options, types_1.Emulators.HOSTING)) {
-        const hostingAddr = await getAndCheckAddress(types_1.Emulators.HOSTING, options);
+    if (listenForEmulator.hosting) {
+        const hostingAddr = legacyGetFirstAddr(types_1.Emulators.HOSTING);
         const hostingEmulator = new hostingEmulator_1.HostingEmulator({
             host: hostingAddr.host,
             port: hostingAddr.port,
@@ -551,17 +523,20 @@ async function startAll(options, showUI = true) {
             "products have an interaction layer in Emulator UI or it cannot " +
             "determine the Project ID. Pass the --project flag to specify a project.");
     }
-    if (showUI && (shouldStart(options, types_1.Emulators.UI) || START_LOGGING_EMULATOR)) {
-        const loggingAddr = await getAndCheckAddress(types_1.Emulators.LOGGING, options);
+    if (listenForEmulator.logging) {
+        const loggingAddr = legacyGetFirstAddr(types_1.Emulators.LOGGING);
         const loggingEmulator = new loggingEmulator_1.LoggingEmulator({
             host: loggingAddr.host,
             port: loggingAddr.port,
         });
         await startEmulator(loggingEmulator);
     }
-    if (showUI && shouldStart(options, types_1.Emulators.UI)) {
-        const uiAddr = await getAndCheckAddress(types_1.Emulators.UI, options);
-        const ui = new ui_1.EmulatorUI(Object.assign({ projectId: projectId, auto_download: true }, uiAddr));
+    if (listenForEmulator.ui) {
+        const ui = new ui_1.EmulatorUI({
+            projectId: projectId,
+            auto_download: true,
+            listen: listenForEmulator[types_1.Emulators.UI],
+        });
         await startEmulator(ui);
     }
     let serviceEmulatorCount = 0;
@@ -583,6 +558,29 @@ async function startAll(options, showUI = true) {
     return { deprecationNotices: [] };
 }
 exports.startAll = startAll;
+function getListenConfig(options, emulator) {
+    var _a, _b, _c, _d;
+    let host = ((_b = (_a = options.config.src.emulators) === null || _a === void 0 ? void 0 : _a[emulator]) === null || _b === void 0 ? void 0 : _b.host) || constants_1.Constants.getDefaultHost();
+    if (host === "localhost" && utils.isRunningInWSL()) {
+        host = "127.0.0.1";
+    }
+    const portVal = (_d = (_c = options.config.src.emulators) === null || _c === void 0 ? void 0 : _c[emulator]) === null || _d === void 0 ? void 0 : _d.port;
+    let port;
+    let portFixed;
+    if (portVal) {
+        port = parseInt(`${portVal}`, 10);
+        portFixed = true;
+    }
+    else {
+        port = constants_1.Constants.getDefaultPort(emulator);
+        portFixed = !constants_1.FIND_AVAILBLE_PORT_BY_DEFAULT[emulator];
+    }
+    return {
+        host,
+        port,
+        portFixed,
+    };
+}
 async function exportEmulatorData(exportPath, options, initiatedBy) {
     const projectId = options.project;
     if (!projectId) {
@@ -592,14 +590,15 @@ async function exportEmulatorData(exportPath, options, initiatedBy) {
     if (!hubClient.foundHub()) {
         throw new error_1.FirebaseError(`Did not find any running emulators for project ${clc.bold(projectId)}.`, { exit: 1 });
     }
+    let origin;
     try {
-        await hubClient.getStatus();
+        origin = await hubClient.getStatus();
     }
     catch (e) {
         const filePath = hub_1.EmulatorHub.getLocatorFilePath(projectId);
         throw new error_1.FirebaseError(`The emulator hub for ${projectId} did not respond to a status check. If this error continues try shutting down all running emulators and deleting the file ${filePath}`, { exit: 1 });
     }
-    utils.logBullet(`Found running emulator hub for project ${clc.bold(projectId)} at ${hubClient.origin}`);
+    utils.logBullet(`Found running emulator hub for project ${clc.bold(projectId)} at ${origin}`);
     const exportAbsPath = path.resolve(exportPath);
     if (!fs.existsSync(exportAbsPath)) {
         utils.logBullet(`Creating export directory ${exportAbsPath}`);

package/lib/emulator/databaseEmulator.js

@@ -13,7 +13,7 @@ const registry_1 = require("./registry");
 const emulatorLogger_1 = require("./emulatorLogger");
 const error_1 = require("../error");
 const parseBoltRules_1 = require("../parseBoltRules");
-const apiv2_1 = require("../apiv2");
+const utils_1 = require("../utils");
 class DatabaseEmulator {
     constructor(args) {
         this.args = args;
@@ -94,7 +94,7 @@ class DatabaseEmulator {
         await new Promise((resolve, reject) => {
             const req = http.request({
                 method: "PUT",
-                host,
+                host: (0, utils_1.connectableHostname)(host),
                 port,
                 path: `/.json?ns=${ns}&disableTriggers=true&writeSizeLimit=unlimited`,
                 headers: {
@@ -127,13 +127,8 @@ class DatabaseEmulator {
         const content = rulesExt === ".bolt"
             ? (0, parseBoltRules_1.parseBoltRules)(rulesPath).toString()
             : fs.readFileSync(rulesPath, "utf8");
-        const info = this.getInfo();
         try {
-            const client = new apiv2_1.Client({
-                urlPrefix: `http://${registry_1.EmulatorRegistry.getInfoHostString(info)}`,
-                auth: false,
-            });
-            await client.put(`/.settings/rules.json`, content, {
+            await registry_1.EmulatorRegistry.client(types_1.Emulators.DATABASE).put(`/.settings/rules.json`, content, {
                 headers: { Authorization: "Bearer owner" },
                 queryParams: { ns: instance },
             });

package/lib/emulator/dns.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Resolver = exports.IPV6_UNSPECIFIED = exports.IPV4_UNSPECIFIED = exports.IPV6_LOOPBACK = exports.IPV4_LOOPBACK = void 0;
+const node_dns_1 = require("node:dns");
+const node_net_1 = require("node:net");
+const logger_1 = require("../logger");
+exports.IPV4_LOOPBACK = { address: "127.0.0.1", family: 4 };
+exports.IPV6_LOOPBACK = { address: "::1", family: 6 };
+exports.IPV4_UNSPECIFIED = { address: "0.0.0.0", family: 4 };
+exports.IPV6_UNSPECIFIED = { address: "::", family: 6 };
+class Resolver {
+    constructor(lookup = node_dns_1.promises.lookup) {
+        this.lookup = lookup;
+        this.cache = new Map([
+            ["localhost", [exports.IPV4_LOOPBACK, exports.IPV6_LOOPBACK]],
+        ]);
+    }
+    async lookupFirst(hostname) {
+        const addresses = await this.lookupAll(hostname);
+        if (addresses.length === 1) {
+            return addresses[0];
+        }
+        const result = addresses[0];
+        const discarded = [];
+        for (let i = 1; i < addresses.length; i++) {
+            discarded.push(result.address);
+        }
+        logger_1.logger.debug(`Resolved hostname "${hostname}" to the first result "${result.address}" (ignoring candidates: ${discarded.join(",")}).`);
+        return result;
+    }
+    async lookupAll(hostname) {
+        const family = (0, node_net_1.isIP)(hostname);
+        if (family > 0) {
+            return [{ family, address: hostname }];
+        }
+        const cached = this.cache.get(hostname);
+        if (cached) {
+            return cached;
+        }
+        const addresses = await this.lookup(hostname, {
+            verbatim: false,
+            all: true,
+        });
+        this.cache.set(hostname, addresses);
+        return addresses;
+    }
+}
+exports.Resolver = Resolver;
+Resolver.DEFAULT = new Resolver();

package/lib/emulator/downloadableEmulators.js

@@ -18,13 +18,13 @@ const EMULATOR_INSTANCE_KILL_TIMEOUT = 4000;
 const CACHE_DIR = process.env.FIREBASE_EMULATORS_PATH || path.join(os.homedir(), ".cache", "firebase", "emulators");
 exports.DownloadDetails = {
     database: {
-        downloadPath: path.join(CACHE_DIR, "firebase-database-emulator-v4.9.0.jar"),
-        version: "4.9.0",
+        downloadPath: path.join(CACHE_DIR, "firebase-database-emulator-v4.10.0.jar"),
+        version: "4.10.0",
         opts: {
             cacheDir: CACHE_DIR,
-            remoteUrl: "https://storage.googleapis.com/firebase-preview-drop/emulator/firebase-database-emulator-v4.9.0.jar",
-            expectedSize: 34204485,
-            expectedChecksum: "1c3f5974f0ee5559ebf27b56f2e62108",
+            remoteUrl: "https://storage.googleapis.com/firebase-preview-drop/emulator/firebase-database-emulator-v4.10.0.jar",
+            expectedSize: 34230230,
+            expectedChecksum: "e99b23f0e723813de4f4ea0e879b46b0",
             namePrefix: "firebase-database-emulator",
         },
     },
@@ -67,15 +67,15 @@ exports.DownloadDetails = {
             },
         }
         : {
-            version: "1.10.0",
-            downloadPath: path.join(CACHE_DIR, "ui-v1.10.0.zip"),
-            unzipDir: path.join(CACHE_DIR, "ui-v1.10.0"),
-            binaryPath: path.join(CACHE_DIR, "ui-v1.10.0", "server", "server.js"),
+            version: "1.11.1",
+            downloadPath: path.join(CACHE_DIR, "ui-v1.11.1.zip"),
+            unzipDir: path.join(CACHE_DIR, "ui-v1.11.1"),
+            binaryPath: path.join(CACHE_DIR, "ui-v1.11.1", "server", "server.js"),
             opts: {
                 cacheDir: CACHE_DIR,
-                remoteUrl: "https://storage.googleapis.com/firebase-preview-drop/emulator/ui-v1.10.0.zip",
-                expectedSize: 3062540,
-                expectedChecksum: "7dec1e82acccc196efc4d364e2664288",
+                remoteUrl: "https://storage.googleapis.com/firebase-preview-drop/emulator/ui-v1.11.1.zip",
+                expectedSize: 3061713,
+                expectedChecksum: "a4944414518be206280b495f526f18bf",
                 namePrefix: "ui",
             },
         },
@@ -124,7 +124,13 @@ const Commands = {
     database: {
         binary: "java",
         args: ["-Duser.language=en", "-jar", getExecPath(types_1.Emulators.DATABASE)],
-        optionalArgs: ["port", "host", "functions_emulator_port", "functions_emulator_host"],
+        optionalArgs: [
+            "port",
+            "host",
+            "functions_emulator_port",
+            "functions_emulator_host",
+            "single_project_mode",
+        ],
         joinArgs: false,
     },
     firestore: {

package/lib/emulator/emulatorLogger.js

@@ -4,6 +4,7 @@ exports.EmulatorLogger = exports.Verbosity = void 0;
 const clc = require("colorette");
 const utils = require("../utils");
 const logger_1 = require("../logger");
+const types_1 = require("./types");
 const utils_1 = require("../utils");
 const TYPE_VERBOSITY = {
     DEBUG: 0,
@@ -22,11 +23,12 @@ var Verbosity;
     Verbosity[Verbosity["QUIET"] = 2] = "QUIET";
 })(Verbosity = exports.Verbosity || (exports.Verbosity = {}));
 class EmulatorLogger {
-    constructor(data = {}) {
+    constructor(name, data = {}) {
+        this.name = name;
         this.data = data;
     }
     static forEmulator(emulator) {
-        return new EmulatorLogger({
+        return new EmulatorLogger(emulator, {
             metadata: {
                 emulator: {
                     name: emulator,
@@ -35,10 +37,10 @@ class EmulatorLogger {
         });
     }
     static forFunction(functionName, extensionLogInfo) {
-        return new EmulatorLogger({
+        return new EmulatorLogger(types_1.Emulators.FUNCTIONS, {
             metadata: {
                 emulator: {
-                    name: "functions",
+                    name: types_1.Emulators.FUNCTIONS,
                 },
                 function: {
                     name: functionName,
@@ -48,10 +50,10 @@ class EmulatorLogger {
         });
     }
     static forExtension(extensionLogInfo) {
-        return new EmulatorLogger({
+        return new EmulatorLogger(types_1.Emulators.EXTENSIONS, {
             metadata: {
                 emulator: {
-                    name: "extensions",
+                    name: types_1.Emulators.EXTENSIONS,
                 },
                 extension: extensionLogInfo,
             },
@@ -186,7 +188,12 @@ You can probably fix this by running "npm install ${systemLog.data.name}@latest"
             default:
         }
     }
-    logLabeled(type, label, text) {
+    logLabeled(type, labelOrText, text) {
+        let label = labelOrText;
+        if (text === undefined) {
+            text = label;
+            label = this.name;
+        }
         if (EmulatorLogger.shouldSupress(type)) {
             logger_1.logger.debug(`[${label}] ${text}`);
             return;

package/lib/emulator/env.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setEnvVarsForEmulators = void 0;
+const constants_1 = require("./constants");
+const types_1 = require("./types");
+const registry_1 = require("./registry");
+function setEnvVarsForEmulators(env) {
+    if (registry_1.EmulatorRegistry.isRunning(types_1.Emulators.DATABASE)) {
+        env[constants_1.Constants.FIREBASE_DATABASE_EMULATOR_HOST] = registry_1.EmulatorRegistry.url(types_1.Emulators.DATABASE).host;
+    }
+    if (registry_1.EmulatorRegistry.isRunning(types_1.Emulators.FIRESTORE)) {
+        const { host } = registry_1.EmulatorRegistry.url(types_1.Emulators.FIRESTORE);
+        env[constants_1.Constants.FIRESTORE_EMULATOR_HOST] = host;
+        env[constants_1.Constants.FIRESTORE_EMULATOR_ENV_ALT] = host;
+    }
+    if (registry_1.EmulatorRegistry.isRunning(types_1.Emulators.STORAGE)) {
+        const { host } = registry_1.EmulatorRegistry.url(types_1.Emulators.STORAGE);
+        env[constants_1.Constants.FIREBASE_STORAGE_EMULATOR_HOST] = host;
+        env[constants_1.Constants.CLOUD_STORAGE_EMULATOR_HOST] = `http://${host}`;
+    }
+    if (registry_1.EmulatorRegistry.isRunning(types_1.Emulators.AUTH)) {
+        env[constants_1.Constants.FIREBASE_AUTH_EMULATOR_HOST] = registry_1.EmulatorRegistry.url(types_1.Emulators.AUTH).host;
+    }
+    if (registry_1.EmulatorRegistry.isRunning(types_1.Emulators.HUB)) {
+        env[constants_1.Constants.FIREBASE_EMULATOR_HUB] = registry_1.EmulatorRegistry.url(types_1.Emulators.HUB).host;
+    }
+    const pubsubEmulator = registry_1.EmulatorRegistry.isRunning(types_1.Emulators.PUBSUB);
+    if (pubsubEmulator) {
+        env[constants_1.Constants.PUBSUB_EMULATOR_HOST] = registry_1.EmulatorRegistry.url(types_1.Emulators.PUBSUB).host;
+    }
+    if (registry_1.EmulatorRegistry.isRunning(types_1.Emulators.EVENTARC)) {
+        env[constants_1.Constants.CLOUD_EVENTARC_EMULATOR_HOST] = `http://${registry_1.EmulatorRegistry.url(types_1.Emulators.EVENTARC).host}`;
+    }
+}
+exports.setEnvVarsForEmulators = setEnvVarsForEmulators;