firebase-tools 11.14.1 → 11.14.2

package/lib/emulator/portUtils.js

@@ -1,13 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.waitForPortClosed = exports.checkPortOpen = exports.findAvailablePort = exports.suggestUnrestricted = exports.isRestricted = void 0;
-const pf = require("portfinder");
+exports.resolveHostAndAssignPorts = exports.waitForPortClosed = exports.checkListenable = void 0;
+const clc = require("colorette");
 const tcpport = require("tcp-port-used");
-const dns = require("dns");
+const node_net_1 = require("node:net");
 const error_1 = require("../error");
-const logger_1 = require("../logger");
-dns.setDefaultResultOrder("ipv4first");
-const RESTRICTED_PORTS = [
+const utils = require("../utils");
+const dns_1 = require("./dns");
+const types_1 = require("./types");
+const constants_1 = require("./constants");
+const emulatorLogger_1 = require("./emulatorLogger");
+const RESTRICTED_PORTS = new Set([
     1,
     7,
     9,
@@ -75,11 +78,10 @@ const RESTRICTED_PORTS = [
     6668,
     6669,
     6697,
-];
+]);
 function isRestricted(port) {
-    return RESTRICTED_PORTS.includes(port);
+    return RESTRICTED_PORTS.has(port);
 }
-exports.isRestricted = isRestricted;
 function suggestUnrestricted(port) {
     if (!isRestricted(port)) {
         return port;
@@ -90,27 +92,37 @@ function suggestUnrestricted(port) {
     }
     return newPort;
 }
-exports.suggestUnrestricted = suggestUnrestricted;
-async function findAvailablePort(host, start, avoidRestricted = true) {
-    const openPort = await pf.getPortPromise({ host, port: start });
-    if (avoidRestricted && isRestricted(openPort)) {
-        logger_1.logger.debug(`portUtils: skipping restricted port ${openPort}`);
-        return findAvailablePort(host, suggestUnrestricted(openPort), avoidRestricted);
-    }
-    return openPort;
-}
-exports.findAvailablePort = findAvailablePort;
-async function checkPortOpen(port, host) {
-    try {
-        const inUse = await tcpport.check(port, host);
-        return !inUse;
-    }
-    catch (e) {
-        logger_1.logger.debug(`port check error: ${e}`);
-        return false;
-    }
+async function checkListenable(arg1, port) {
+    const addr = port === undefined ? arg1 : listenSpec(arg1, port);
+    return new Promise((resolve, reject) => {
+        const dummyServer = (0, node_net_1.createServer)(() => {
+        });
+        dummyServer.once("error", (err) => {
+            dummyServer.removeAllListeners();
+            const e = err;
+            if (e.code === "EADDRINUSE" || e.code === "EACCES") {
+                resolve(false);
+            }
+            else {
+                reject(e);
+            }
+        });
+        dummyServer.once("listening", () => {
+            dummyServer.removeAllListeners();
+            dummyServer.close((err) => {
+                dummyServer.removeAllListeners();
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(true);
+                }
+            });
+        });
+        dummyServer.listen({ host: addr.address, port: addr.port, ipv6Only: addr.family === "IPv6" });
+    });
 }
-exports.checkPortOpen = checkPortOpen;
+exports.checkListenable = checkListenable;
 async function waitForPortClosed(port, host) {
     const interval = 250;
     const timeout = 60000;
@@ -122,3 +134,170 @@ async function waitForPortClosed(port, host) {
     }
 }
 exports.waitForPortClosed = waitForPortClosed;
+const EMULATOR_CAN_LISTEN_ON_PRIMARY_ONLY = {
+    database: true,
+    firestore: true,
+    "firestore.websocket": true,
+    pubsub: true,
+    hub: false,
+    ui: false,
+    auth: true,
+    eventarc: true,
+    extensions: true,
+    functions: true,
+    logging: true,
+    storage: true,
+    hosting: true,
+};
+const MAX_PORT = 65535;
+async function resolveHostAndAssignPorts(listenConfig) {
+    const lookupForHost = new Map();
+    const takenPorts = new Map();
+    const result = {};
+    const tasks = [];
+    for (const name of Object.keys(listenConfig)) {
+        const config = listenConfig[name];
+        if (!config) {
+            continue;
+        }
+        else if (config instanceof Array) {
+            result[name] = config;
+            for (const { port } of config) {
+                takenPorts.set(port, name);
+            }
+            continue;
+        }
+        const { host, port, portFixed } = config;
+        let lookup = lookupForHost.get(host);
+        if (!lookup) {
+            lookup = dns_1.Resolver.DEFAULT.lookupAll(host);
+            lookupForHost.set(host, lookup);
+        }
+        const findAddrs = lookup.then(async (addrs) => {
+            const emuLogger = emulatorLogger_1.EmulatorLogger.forEmulator(name === "firestore.websocket" ? types_1.Emulators.FIRESTORE : name);
+            if (addrs.some((addr) => addr.address === dns_1.IPV6_UNSPECIFIED.address)) {
+                if (!addrs.some((addr) => addr.address === dns_1.IPV4_UNSPECIFIED.address)) {
+                    emuLogger.logLabeled("DEBUG", name, `testing listening on IPv4 wildcard in addition to IPv6. To listen on IPv6 only, use "::0" instead.`);
+                    addrs.push(dns_1.IPV4_UNSPECIFIED);
+                }
+            }
+            for (let p = port; p <= MAX_PORT; p++) {
+                if (takenPorts.has(p)) {
+                    continue;
+                }
+                if (!portFixed && RESTRICTED_PORTS.has(p)) {
+                    emuLogger.logLabeled("DEBUG", name, `portUtils: skipping restricted port ${p}`);
+                    continue;
+                }
+                const available = [];
+                const unavailable = [];
+                let i;
+                for (i = 0; i < addrs.length; i++) {
+                    const addr = addrs[i];
+                    const listen = listenSpec(addr, p);
+                    if (await checkListenable(listen)) {
+                        available.push(listen);
+                    }
+                    else {
+                        if (!portFixed) {
+                            if (i > 0) {
+                                emuLogger.logLabeled("DEBUG", name, `Port ${p} taken on secondary address ${addr.address}, will keep searching to find a better port.`);
+                            }
+                            break;
+                        }
+                        unavailable.push(addr.address);
+                    }
+                }
+                if (i === addrs.length) {
+                    if (unavailable.length > 0) {
+                        if (unavailable[0] === addrs[0].address) {
+                            return fixedPortNotAvailable(name, host, port, emuLogger, unavailable);
+                        }
+                        warnPartiallyAvailablePort(emuLogger, port, available, unavailable);
+                    }
+                    if (takenPorts.has(p)) {
+                        continue;
+                    }
+                    takenPorts.set(p, name);
+                    if (RESTRICTED_PORTS.has(p)) {
+                        const suggested = suggestUnrestricted(port);
+                        emuLogger.logLabeled("WARN", name, `Port ${port} is restricted by some web browsers, including Chrome. You may want to choose a different port such as ${suggested}.`);
+                    }
+                    if (p !== port && name !== "firestore.websocket") {
+                        emuLogger.logLabeled("WARN", `${portDescription(name)} unable to start on port ${port}, starting on ${p} instead.`);
+                    }
+                    if (available.length > 1 && EMULATOR_CAN_LISTEN_ON_PRIMARY_ONLY[name]) {
+                        emuLogger.logLabeled("DEBUG", name, `${portDescription(name)} only supports listening on one address (${available[0].address}). Not listening on ${addrs
+                            .slice(1)
+                            .map((s) => s.address)
+                            .join(",")}`);
+                        result[name] = [available[0]];
+                    }
+                    else {
+                        result[name] = available;
+                    }
+                    return;
+                }
+            }
+            return utils.reject(`Could not find any open port in ${port}-${MAX_PORT} for ${portDescription(name)}`, {});
+        });
+        tasks.push(findAddrs);
+    }
+    await Promise.all(tasks);
+    return result;
+}
+exports.resolveHostAndAssignPorts = resolveHostAndAssignPorts;
+function portDescription(name) {
+    return name === "firestore.websocket"
+        ? `websocket server for ${types_1.Emulators.FIRESTORE}`
+        : constants_1.Constants.description(name);
+}
+function warnPartiallyAvailablePort(emuLogger, port, available, unavailable) {
+    emuLogger.logLabeled("WARN", `Port ${port} is available on ` +
+        available.map((s) => s.address).join(",") +
+        ` but not ${unavailable.join(",")}. This may cause issues with some clients.`);
+    emuLogger.logLabeled("WARN", `If you encounter connectivity issues, consider switching to a different port or explicitly specifying ${clc.yellow('"host": "<ip address>"')} instead of hostname in firebase.json`);
+}
+function fixedPortNotAvailable(name, host, port, emuLogger, unavailableAddrs) {
+    if (unavailableAddrs.length !== 1 || unavailableAddrs[0] !== host) {
+        host = `${host} (${unavailableAddrs.join(",")})`;
+    }
+    const description = portDescription(name);
+    emuLogger.logLabeled("WARN", `Port ${port} is not open on ${host}, could not start ${description}.`);
+    if (name === "firestore.websocket") {
+        emuLogger.logLabeled("WARN", `To select a different port, specify that port in a firebase.json config file:
+      {
+        // ...
+        "emulators": {
+          "${types_1.Emulators.FIRESTORE}": {
+            "host": "${clc.yellow("HOST")}",
+            ...
+            "websocketPort": "${clc.yellow("WEBSOCKET_PORT")}"
+          }
+        }
+      }`);
+    }
+    else {
+        emuLogger.logLabeled("WARN", `To select a different host/port, specify that host/port in a firebase.json config file:
+      {
+        // ...
+        "emulators": {
+          "${emuLogger.name}": {
+            "host": "${clc.yellow("HOST")}",
+            "port": "${clc.yellow("PORT")}"
+          }
+        }
+      }`);
+    }
+    return utils.reject(`Could not start ${description}, port taken.`, {});
+}
+function listenSpec(lookup, port) {
+    if (lookup.family !== 4 && lookup.family !== 6) {
+        throw new Error(`Unsupported address family "${lookup.family}" for address ${lookup.address}.`);
+    }
+    return {
+        address: lookup.address,
+        family: lookup.family === 4 ? "IPv4" : "IPv6",
+        port: port,
+    };
+}

package/lib/emulator/pubsubEmulator.js

@@ -4,7 +4,6 @@ exports.PubsubEmulator = void 0;
 const uuid = require("uuid");
 const pubsub_1 = require("@google-cloud/pubsub");
 const downloadableEmulators = require("./downloadableEmulators");
-const apiv2_1 = require("../apiv2");
 const emulatorLogger_1 = require("./emulatorLogger");
 const types_1 = require("../emulator/types");
 const constants_1 = require("./constants");
@@ -14,14 +13,18 @@ class PubsubEmulator {
     constructor(args) {
         this.args = args;
         this.logger = emulatorLogger_1.EmulatorLogger.forEmulator(types_1.Emulators.PUBSUB);
-        const { host, port } = this.getInfo();
-        this.pubsub = new pubsub_1.PubSub({
-            apiEndpoint: `${host}:${port}`,
-            projectId: this.args.projectId,
-        });
         this.triggersForTopic = new Map();
         this.subscriptionForTopic = new Map();
     }
+    get pubsub() {
+        if (!this._pubsub) {
+            this._pubsub = new pubsub_1.PubSub({
+                apiEndpoint: registry_1.EmulatorRegistry.url(types_1.Emulators.PUBSUB).host,
+                projectId: this.args.projectId,
+            });
+        }
+        return this._pubsub;
+    }
     async start() {
         return downloadableEmulators.start(types_1.Emulators.PUBSUB, this.args);
     }
@@ -94,14 +97,10 @@ class PubsubEmulator {
     ensureFunctionsClient() {
         if (this.client !== undefined)
             return;
-        const funcEmulator = registry_1.EmulatorRegistry.get(types_1.Emulators.FUNCTIONS);
-        if (!funcEmulator) {
+        if (!registry_1.EmulatorRegistry.isRunning(types_1.Emulators.FUNCTIONS)) {
             throw new error_1.FirebaseError(`Attempted to execute pubsub trigger but could not find the Functions emulator`);
         }
-        this.client = new apiv2_1.Client({
-            urlPrefix: `http://${registry_1.EmulatorRegistry.getInfoHostString(funcEmulator.getInfo())}`,
-            auth: false,
-        });
+        this.client = registry_1.EmulatorRegistry.client(types_1.Emulators.FUNCTIONS);
     }
     createLegacyEventRequestBody(topic, message) {
         return {

package/lib/emulator/registry.js

@@ -6,6 +6,8 @@ const error_1 = require("../error");
 const portUtils = require("./portUtils");
 const constants_1 = require("./constants");
 const emulatorLogger_1 = require("./emulatorLogger");
+const utils_1 = require("../utils");
+const apiv2_1 = require("../apiv2");
 class EmulatorRegistry {
     static async start(instance) {
         const description = constants_1.Constants.description(instance.getName());
@@ -16,7 +18,7 @@ class EmulatorRegistry {
         await instance.start();
         if (instance.getName() !== types_1.Emulators.EXTENSIONS) {
             const info = instance.getInfo();
-            await portUtils.waitForPortClosed(info.port, info.host);
+            await portUtils.waitForPortClosed(info.port, (0, utils_1.connectableHostname)(info.host));
         }
     }
     static async stop(name) {
@@ -74,20 +76,12 @@ class EmulatorRegistry {
         return this.INSTANCES.get(emulator);
     }
     static getInfo(emulator) {
-        const instance = this.INSTANCES.get(emulator === types_1.Emulators.EXTENSIONS ? types_1.Emulators.FUNCTIONS : emulator);
-        if (!instance) {
+        var _a;
+        const info = (_a = EmulatorRegistry.get(emulator)) === null || _a === void 0 ? void 0 : _a.getInfo();
+        if (!info) {
             return undefined;
         }
-        return instance.getInfo();
-    }
-    static getInfoHostString(info) {
-        const { host, port } = info;
-        if (host.includes(":")) {
-            return `[${host}]:${port}`;
-        }
-        else {
-            return `${host}:${port}`;
-        }
+        return Object.assign(Object.assign({}, info), { host: (0, utils_1.connectableHostname)(info.host) });
     }
     static url(emulator, req) {
         const url = new URL("http://unknown/");
@@ -101,13 +95,7 @@ class EmulatorRegistry {
         }
         const info = EmulatorRegistry.getInfo(emulator);
         if (info) {
-            if (info.host === "0.0.0.0") {
-                url.hostname = "127.0.0.1";
-            }
-            else if (info.host === "::") {
-                url.hostname = "[::1]";
-            }
-            else if (info.host.includes(":")) {
+            if (info.host.includes(":")) {
                 url.hostname = `[${info.host}]`;
             }
             else {
@@ -120,6 +108,9 @@ class EmulatorRegistry {
         }
         return url;
     }
+    static client(emulator, options = {}) {
+        return new apiv2_1.Client(Object.assign({ urlPrefix: EmulatorRegistry.url(emulator).toString(), auth: false }, options));
+    }
     static set(emulator, instance) {
         this.INSTANCES.set(emulator, instance);
     }

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

@@ -187,7 +187,6 @@ function createCloudEndpoints(emulator) {
         return res.json(new metadata_1.CloudStorageObjectMetadata(metadata));
     });
     gcloudStorageAPI.post("/b/:bucketId/o/:objectId/acl", async (req, res) => {
-        var _a, _b;
         emulatorLogger_1.EmulatorLogger.forEmulator(types_1.Emulators.STORAGE).log("WARN_ONCE", "Cloud Storage ACLs are not supported in the Storage Emulator. All related methods will succeed, but have no effect.");
         let getObjectResponse;
         try {
@@ -207,11 +206,13 @@ function createCloudEndpoints(emulator) {
         }
         const { metadata } = getObjectResponse;
         metadata.update({});
+        const selfLink = registry_1.EmulatorRegistry.url(types_1.Emulators.STORAGE);
+        selfLink.pathname = `/storage/v1/b/${metadata.bucket}/o/${encodeURIComponent(metadata.name)}/acl/allUsers`;
         return res.json({
             kind: "storage#objectAccessControl",
             object: metadata.name,
             id: `${req.params.bucketId}/${metadata.name}/${metadata.generation}/allUsers`,
-            selfLink: `http://${(_a = registry_1.EmulatorRegistry.getInfo(types_1.Emulators.STORAGE)) === null || _a === void 0 ? void 0 : _a.host}:${(_b = registry_1.EmulatorRegistry.getInfo(types_1.Emulators.STORAGE)) === null || _b === void 0 ? void 0 : _b.port}/storage/v1/b/${metadata.bucket}/o/${encodeURIComponent(metadata.name)}/acl/allUsers`,
+            selfLink: selfLink.toString(),
             bucket: metadata.bucket,
             entity: req.body.entity,
             role: req.body.role,
@@ -222,10 +223,6 @@ function createCloudEndpoints(emulator) {
     gcloudStorageAPI.post("/upload/storage/v1/b/:bucketId/o", async (req, res) => {
         const uploadType = req.query.uploadType || req.header("X-Goog-Upload-Protocol");
         if (uploadType === "resumable") {
-            const emulatorInfo = registry_1.EmulatorRegistry.getInfo(types_1.Emulators.STORAGE);
-            if (emulatorInfo === undefined) {
-                return res.sendStatus(500);
-            }
             const name = getIncomingFileNameFromRequest(req.query, req.body);
             if (name === undefined) {
                 res.sendStatus(400);

package/lib/emulator/storage/cloudFunctions.js

@@ -6,7 +6,6 @@ const registry_1 = require("../registry");
 const types_1 = require("../types");
 const emulatorLogger_1 = require("../emulatorLogger");
 const metadata_1 = require("./metadata");
-const apiv2_1 = require("../../apiv2");
 const STORAGE_V2_ACTION_MAP = {
     finalize: "finalized",
     metadataUpdate: "metadataUpdated",
@@ -17,16 +16,12 @@ class StorageCloudFunctions {
     constructor(projectId) {
         this.projectId = projectId;
         this.logger = emulatorLogger_1.EmulatorLogger.forEmulator(types_1.Emulators.STORAGE);
-        this.multicastOrigin = "";
         this.multicastPath = "";
         this.enabled = false;
-        const functionsEmulator = registry_1.EmulatorRegistry.get(types_1.Emulators.FUNCTIONS);
-        if (functionsEmulator) {
+        if (registry_1.EmulatorRegistry.isRunning(types_1.Emulators.FUNCTIONS)) {
             this.enabled = true;
-            this.functionsEmulatorInfo = functionsEmulator.getInfo();
-            this.multicastOrigin = `http://${registry_1.EmulatorRegistry.getInfoHostString(this.functionsEmulatorInfo)}`;
             this.multicastPath = `/functions/projects/${projectId}/trigger_multicast`;
-            this.client = new apiv2_1.Client({ urlPrefix: this.multicastOrigin, auth: false });
+            this.client = registry_1.EmulatorRegistry.client(types_1.Emulators.FUNCTIONS);
         }
     }
     async dispatch(action, object) {

package/lib/emulator/storage/metadata.js

@@ -237,11 +237,12 @@ class OutgoingFirebaseMetadata {
 exports.OutgoingFirebaseMetadata = OutgoingFirebaseMetadata;
 class CloudStorageBucketMetadata {
     constructor(id) {
-        var _a, _b;
         this.kind = "storage#bucket";
         this.name = id;
         this.id = id;
-        this.selfLink = `http://${(_a = registry_1.EmulatorRegistry.getInfo(types_1.Emulators.STORAGE)) === null || _a === void 0 ? void 0 : _a.host}:${(_b = registry_1.EmulatorRegistry.getInfo(types_1.Emulators.STORAGE)) === null || _b === void 0 ? void 0 : _b.port}/v1/b/${this.id}`;
+        const selfLink = registry_1.EmulatorRegistry.url(types_1.Emulators.STORAGE);
+        selfLink.pathname = `/v1/b/${this.id}`;
+        this.selfLink = selfLink.toString();
         this.timeCreated = toSerializedDate(new Date());
         this.updated = this.timeCreated;
         this.projectNumber = "000000000000";
@@ -269,7 +270,6 @@ class CloudStorageObjectAccessControlMetadata {
 exports.CloudStorageObjectAccessControlMetadata = CloudStorageObjectAccessControlMetadata;
 class CloudStorageObjectMetadata {
     constructor(metadata) {
-        var _a, _b, _c, _d;
         this.kind = "storage#object";
         this.name = metadata.name;
         this.bucket = metadata.bucket;
@@ -311,8 +311,14 @@ class CloudStorageObjectMetadata {
         this.crc32c = (0, crc_1.crc32cToString)(metadata.crc32c);
         this.timeStorageClassUpdated = toSerializedDate(metadata.timeCreated);
         this.id = `${metadata.bucket}/${metadata.name}/${metadata.generation}`;
-        this.selfLink = `http://${(_a = registry_1.EmulatorRegistry.getInfo(types_1.Emulators.STORAGE)) === null || _a === void 0 ? void 0 : _a.host}:${(_b = registry_1.EmulatorRegistry.getInfo(types_1.Emulators.STORAGE)) === null || _b === void 0 ? void 0 : _b.port}/storage/v1/b/${metadata.bucket}/o/${encodeURIComponent(metadata.name)}`;
-        this.mediaLink = `http://${(_c = registry_1.EmulatorRegistry.getInfo(types_1.Emulators.STORAGE)) === null || _c === void 0 ? void 0 : _c.host}:${(_d = registry_1.EmulatorRegistry.getInfo(types_1.Emulators.STORAGE)) === null || _d === void 0 ? void 0 : _d.port}/download/storage/v1/b/${metadata.bucket}/o/${encodeURIComponent(metadata.name)}?generation=${metadata.generation}&alt=media`;
+        const selfLink = registry_1.EmulatorRegistry.url(types_1.Emulators.STORAGE);
+        selfLink.pathname = `/storage/v1/b/${metadata.bucket}/o/${encodeURIComponent(metadata.name)}`;
+        this.selfLink = selfLink.toString();
+        const mediaLink = registry_1.EmulatorRegistry.url(types_1.Emulators.STORAGE);
+        mediaLink.pathname = `/download/storage/v1/b/${metadata.bucket}/o/${encodeURIComponent(metadata.name)}`;
+        mediaLink.searchParams.set("generation", metadata.generation.toString());
+        mediaLink.searchParams.set("alt", "media");
+        this.mediaLink = mediaLink.toString();
     }
 }
 exports.CloudStorageObjectMetadata = CloudStorageObjectMetadata;

package/lib/emulator/storage/rules/runtime.js

@@ -15,7 +15,6 @@ const download_1 = require("../../download");
 const fs = require("fs-extra");
 const downloadableEmulators_1 = require("../../downloadableEmulators");
 const registry_1 = require("../../registry");
-const apiv2_1 = require("../../../apiv2");
 const lock = new AsyncLock();
 const synchonizationKey = "key";
 class StorageRulesetInstance {
@@ -301,12 +300,8 @@ function toExpressionValue(obj) {
     throw new error_1.FirebaseError(`Cannot convert "${obj}" of type ${typeof obj} for Firebase Storage rules runtime`);
 }
 async function fetchFirestoreDocument(projectId, request) {
-    const url = registry_1.EmulatorRegistry.url(types_2.Emulators.FIRESTORE);
     const pathname = `projects/${projectId}${request.context.path}`;
-    const client = new apiv2_1.Client({
-        urlPrefix: url.toString(),
-        apiVersion: "v1",
-    });
+    const client = registry_1.EmulatorRegistry.client(types_2.Emulators.FIRESTORE, { apiVersion: "v1", auth: true });
     try {
         const doc = await client.get(pathname);
         const { name, fields } = doc.body;

package/lib/emulator/ui.js

@@ -7,6 +7,7 @@ const registry_1 = require("./registry");
 const error_1 = require("../error");
 const constants_1 = require("./constants");
 const track_1 = require("../track");
+const ExpressBasedEmulator_1 = require("./ExpressBasedEmulator");
 class EmulatorUI {
     constructor(args) {
         this.args = args;
@@ -15,13 +16,11 @@ class EmulatorUI {
         if (!registry_1.EmulatorRegistry.isRunning(types_1.Emulators.HUB)) {
             throw new error_1.FirebaseError(`Cannot start ${constants_1.Constants.description(types_1.Emulators.UI)} without ${constants_1.Constants.description(types_1.Emulators.HUB)}!`);
         }
-        const hubInfo = registry_1.EmulatorRegistry.get(types_1.Emulators.HUB).getInfo();
-        const { auto_download: autoDownload, host, port, projectId } = this.args;
+        const { auto_download: autoDownload, projectId } = this.args;
         const env = {
-            HOST: host.toString(),
-            PORT: port.toString(),
+            LISTEN: JSON.stringify(ExpressBasedEmulator_1.ExpressBasedEmulator.listenOptionsFromSpecs(this.args.listen)),
             GCLOUD_PROJECT: projectId,
-            [constants_1.Constants.FIREBASE_EMULATOR_HUB]: registry_1.EmulatorRegistry.getInfoHostString(hubInfo),
+            [constants_1.Constants.FIREBASE_EMULATOR_HUB]: registry_1.EmulatorRegistry.url(types_1.Emulators.HUB).host,
         };
         const session = (0, track_1.emulatorSession)();
         if (session) {
@@ -38,8 +37,8 @@ class EmulatorUI {
     getInfo() {
         return {
             name: this.getName(),
-            host: this.args.host,
-            port: this.args.port,
+            host: this.args.listen[0].address,
+            port: this.args.listen[0].port,
             pid: downloadableEmulators.getPID(types_1.Emulators.UI),
         };
     }

package/lib/experiments.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.flushToDisk = exports.assertEnabled = exports.setEnabled = exports.isEnabled = exports.experimentNameAutocorrect = exports.isValidExperiment = exports.ALL_EXPERIMENTS = void 0;
+exports.flushToDisk = exports.assertEnabled = exports.enableExperimentsFromCliEnvVariable = exports.setEnabled = exports.isEnabled = exports.experimentNameAutocorrect = exports.isValidExperiment = exports.ALL_EXPERIMENTS = void 0;
 const colorette_1 = require("colorette");
 const leven = require("leven");
 const configstore_1 = require("./configstore");
@@ -112,6 +112,15 @@ function setEnabled(name, to) {
     }
 }
 exports.setEnabled = setEnabled;
+function enableExperimentsFromCliEnvVariable() {
+    const experiments = process.env.FIREBASE_CLI_EXPERIMENTS || "";
+    for (const experiment of experiments.split(",")) {
+        if (isValidExperiment(experiment)) {
+            setEnabled(experiment, true);
+        }
+    }
+}
+exports.enableExperimentsFromCliEnvVariable = enableExperimentsFromCliEnvVariable;
 function assertEnabled(name, task) {
     if (!isEnabled(name)) {
         throw new error_1.FirebaseError(`Cannot ${task} because the experiment ${(0, colorette_1.bold)(name)} is not enabled. To enable ${(0, colorette_1.bold)(name)} run ${(0, colorette_1.bold)(`firebase experiments:enable ${name}`)}`);

package/lib/extensions/displayExtensionInfo.js

@@ -9,11 +9,13 @@ const extensionsHelper_1 = require("./extensionsHelper");
 const logger_1 = require("../logger");
 const error_1 = require("../error");
 const iam = require("../gcp/iam");
+const secretsUtils_1 = require("./secretsUtils");
 marked.setOptions({
     renderer: new TerminalRenderer(),
 });
+const TASKS_ROLE = "cloudtasks.enqueuer";
+const TASKS_API = "cloudtasks.googleapis.com";
 async function displayExtInfo(extensionName, publisher, spec, published = false) {
-    var _a, _b;
     const lines = [];
     lines.push(`**Name**: ${spec.displayName}`);
     if (publisher) {
@@ -26,13 +28,17 @@ async function displayExtInfo(extensionName, publisher, spec, published = false)
         if (spec.license) {
             lines.push(`**License**: ${spec.license}`);
         }
-        lines.push(`**Source code**: ${spec.sourceUrl}`);
+        if (spec.sourceUrl) {
+            lines.push(`**Source code**: ${spec.sourceUrl}`);
+        }
     }
-    if ((_a = spec.apis) === null || _a === void 0 ? void 0 : _a.length) {
-        lines.push(displayApis(spec.apis));
+    const apis = impliedApis(spec);
+    if (apis.length) {
+        lines.push(displayApis(apis));
     }
-    if ((_b = spec.roles) === null || _b === void 0 ? void 0 : _b.length) {
-        lines.push(await displayRoles(spec.roles));
+    const roles = impliedRoles(spec);
+    if (roles.length) {
+        lines.push(await displayRoles(roles));
     }
     if (lines.length > 0) {
         utils.logLabeledBullet(extensionsHelper_1.logPrefix, `information about '${clc.bold(extensionName)}':`);
@@ -73,3 +79,34 @@ function displayApis(apis) {
     });
     return "**APIs used by this Extension**:\n" + lines.join("\n");
 }
+function usesTasks(spec) {
+    return spec.resources.some((r) => { var _a; return ((_a = r.properties) === null || _a === void 0 ? void 0 : _a.taskQueueTrigger) !== undefined; });
+}
+function impliedRoles(spec) {
+    var _a, _b, _c;
+    const roles = [];
+    if ((0, secretsUtils_1.usesSecrets)(spec) && !((_a = spec.roles) === null || _a === void 0 ? void 0 : _a.some((r) => r.role === secretsUtils_1.SECRET_ROLE))) {
+        roles.push({
+            role: secretsUtils_1.SECRET_ROLE,
+            reason: "Allows the extension to read secret values from Cloud Secret Manager",
+        });
+    }
+    if (usesTasks(spec) && !((_b = spec.roles) === null || _b === void 0 ? void 0 : _b.some((r) => r.role === TASKS_ROLE))) {
+        roles.push({
+            role: TASKS_ROLE,
+            reason: "Allows the extension to enqueue Cloud Tasks",
+        });
+    }
+    return roles.concat((_c = spec.roles) !== null && _c !== void 0 ? _c : []);
+}
+function impliedApis(spec) {
+    var _a, _b;
+    const apis = [];
+    if (usesTasks(spec) && !((_a = spec.apis) === null || _a === void 0 ? void 0 : _a.some((a) => a.apiName === TASKS_API))) {
+        apis.push({
+            apiName: TASKS_API,
+            reason: "Allows the extension to enqueue Cloud Tasks",
+        });
+    }
+    return apis.concat((_b = spec.apis) !== null && _b !== void 0 ? _b : []);
+}

package/lib/extensions/secretsUtils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.prettySecretName = exports.getSecretLabels = exports.getActiveSecrets = exports.getManagedSecrets = exports.grantFirexServiceAgentSecretAdminRole = exports.usesSecrets = exports.ensureSecretManagerApiEnabled = exports.SECRET_LABEL = void 0;
+exports.prettySecretName = exports.getSecretLabels = exports.getActiveSecrets = exports.getManagedSecrets = exports.grantFirexServiceAgentSecretAdminRole = exports.usesSecrets = exports.ensureSecretManagerApiEnabled = exports.SECRET_ROLE = exports.SECRET_LABEL = void 0;
 const getProjectNumber_1 = require("../getProjectNumber");
 const utils = require("../utils");
 const ensureApiEnabled_1 = require("../ensureApiEnabled");
@@ -9,6 +9,7 @@ const types_1 = require("./types");
 const secretManagerApi = require("../gcp/secretManager");
 const logger_1 = require("../logger");
 exports.SECRET_LABEL = "firebase-extensions-managed";
+exports.SECRET_ROLE = "secretmanager.secretAccessor";
 async function ensureSecretManagerApiEnabled(options) {
     const projectId = (0, projectUtils_1.needProjectId)(options);
     return await (0, ensureApiEnabled_1.ensure)(projectId, "secretmanager.googleapis.com", "extensions", options.markdown);