firebase-tools 11.14.0 → 11.14.2

package/lib/emulator/hubClient.js

@@ -12,23 +12,37 @@ class EmulatorHubClient {
     foundHub() {
         return this.locator !== undefined;
     }
-    async getStatus() {
-        const apiClient = new apiv2_1.Client({ urlPrefix: this.origin, auth: false });
-        await apiClient.get("/");
+    getStatus() {
+        return this.tryOrigins(async (client, origin) => {
+            await client.get("/");
+            return origin;
+        });
+    }
+    async tryOrigins(task) {
+        const origins = this.assertLocator().origins;
+        let err = undefined;
+        for (const origin of origins) {
+            try {
+                const apiClient = new apiv2_1.Client({ urlPrefix: origin, auth: false });
+                return await task(apiClient, origin);
+            }
+            catch (e) {
+                if (!err) {
+                    err = e;
+                }
+            }
+        }
+        throw err !== null && err !== void 0 ? err : new Error("Cannot find working hub origin. Tried:" + origins.join(" "));
     }
     async getEmulators() {
-        const apiClient = new apiv2_1.Client({ urlPrefix: this.origin, auth: false });
-        const res = await apiClient.get(hub_1.EmulatorHub.PATH_EMULATORS);
+        const res = await this.tryOrigins((client) => client.get(hub_1.EmulatorHub.PATH_EMULATORS));
         return res.body;
     }
     async postExport(options) {
-        const apiClient = new apiv2_1.Client({ urlPrefix: this.origin, auth: false });
+        const origin = await this.getStatus();
+        const apiClient = new apiv2_1.Client({ urlPrefix: origin, auth: false });
         await apiClient.post(hub_1.EmulatorHub.PATH_EXPORT, options);
     }
-    get origin() {
-        const locator = this.assertLocator();
-        return `http://${locator.host}:${locator.port}`;
-    }
     assertLocator() {
         if (this.locator === undefined) {
             throw new error_1.FirebaseError(`Cannot contact the Emulator Hub for project ${this.projectId}`);
@@ -37,4 +51,3 @@ class EmulatorHubClient {
     }
 }
 exports.EmulatorHubClient = EmulatorHubClient;
-//# sourceMappingURL=hubClient.js.map

package/lib/emulator/hubExport.js

@@ -12,7 +12,6 @@ const error_1 = require("../error");
 const hub_1 = require("./hub");
 const downloadableEmulators_1 = require("./downloadableEmulators");
 const rimraf = require("rimraf");
-const apiv2_1 = require("../apiv2");
 const track_1 = require("../track");
 class HubExport {
     constructor(projectId, options) {
@@ -83,20 +82,16 @@ class HubExport {
             initiated_by: this.options.initiatedBy,
             emulator_name: types_1.Emulators.FIRESTORE,
         });
-        const firestoreInfo = registry_1.EmulatorRegistry.get(types_1.Emulators.FIRESTORE).getInfo();
-        const firestoreHost = `http://${registry_1.EmulatorRegistry.getInfoHostString(firestoreInfo)}`;
         const firestoreExportBody = {
             database: `projects/${this.projectId}/databases/(default)`,
             export_directory: this.tmpDir,
             export_name: metadata.firestore.path,
         };
-        const client = new apiv2_1.Client({ urlPrefix: firestoreHost, auth: false });
-        await client.post(`/emulator/v1/projects/${this.projectId}:export`, firestoreExportBody);
+        await registry_1.EmulatorRegistry.client(types_1.Emulators.FIRESTORE).post(`/emulator/v1/projects/${this.projectId}:export`, firestoreExportBody);
     }
     async exportDatabase(metadata) {
         const databaseEmulator = registry_1.EmulatorRegistry.get(types_1.Emulators.DATABASE);
-        const databaseAddr = `http://${registry_1.EmulatorRegistry.getInfoHostString(databaseEmulator.getInfo())}`;
-        const client = new apiv2_1.Client({ urlPrefix: databaseAddr, auth: true });
+        const client = registry_1.EmulatorRegistry.client(types_1.Emulators.DATABASE, { auth: true });
         const inspectURL = `/.inspect/databases.json`;
         const inspectRes = await client.get(inspectURL, {
             queryParams: { ns: this.projectId },
@@ -174,19 +169,16 @@ class HubExport {
         }, configFile);
     }
     async exportStorage(metadata) {
-        const storageEmulator = registry_1.EmulatorRegistry.get(types_1.Emulators.STORAGE);
         const storageExportPath = path.join(this.tmpDir, metadata.storage.path);
         if (fs.existsSync(storageExportPath)) {
             fse.removeSync(storageExportPath);
         }
         fs.mkdirSync(storageExportPath, { recursive: true });
-        const storageHost = `http://${registry_1.EmulatorRegistry.getInfoHostString(storageEmulator.getInfo())}`;
         const storageExportBody = {
             path: storageExportPath,
             initiatedBy: this.options.initiatedBy,
         };
-        const client = new apiv2_1.Client({ urlPrefix: storageHost, auth: false });
-        const res = await client.request({
+        const res = await registry_1.EmulatorRegistry.client(types_1.Emulators.STORAGE).request({
             method: "POST",
             path: "/internal/export",
             headers: { "Content-Type": "application/json" },
@@ -214,4 +206,3 @@ function fetchToFile(options, path) {
 function shouldExport(e) {
     return types_1.IMPORT_EXPORT_EMULATORS.includes(e) && registry_1.EmulatorRegistry.isRunning(e);
 }
-//# sourceMappingURL=hubExport.js.map

package/lib/emulator/loggingEmulator.js

@@ -116,4 +116,3 @@ class WebSocketTransport extends TransportStream {
         }
     }
 }
-//# sourceMappingURL=loggingEmulator.js.map

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,4 +134,170 @@ async function waitForPortClosed(port, host) {
     }
 }
 exports.waitForPortClosed = waitForPortClosed;
-//# sourceMappingURL=portUtils.js.map
+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 {
@@ -170,4 +169,3 @@ class PubsubEmulator {
     }
 }
 exports.PubsubEmulator = PubsubEmulator;
-//# sourceMappingURL=pubsubEmulator.js.map

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);
     }
@@ -129,4 +120,3 @@ class EmulatorRegistry {
 }
 exports.EmulatorRegistry = EmulatorRegistry;
 EmulatorRegistry.INSTANCES = new Map();
-//# sourceMappingURL=registry.js.map

package/lib/emulator/shared/request.js

@@ -17,4 +17,3 @@ async function reqBodyToBuffer(req) {
     return Buffer.concat(bufs);
 }
 exports.reqBodyToBuffer = reqBodyToBuffer;
-//# sourceMappingURL=request.js.map

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

@@ -517,4 +517,3 @@ function isValidNonEncodedPathString(path) {
 function removeAtMostOneTrailingSlash(path) {
     return path.replace(/\/$/, "");
 }
-//# sourceMappingURL=firebase.js.map

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);
@@ -430,4 +427,3 @@ function getIncomingFileNameFromRequest(query, metadata) {
     const name = ((_a = query === null || query === void 0 ? void 0 : query.name) === null || _a === void 0 ? void 0 : _a.toString()) || (metadata === null || metadata === void 0 ? void 0 : metadata.name);
     return (name === null || name === void 0 ? void 0 : name.startsWith("/")) ? name.slice(1) : name;
 }
-//# sourceMappingURL=gcloud.js.map

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) {
@@ -91,4 +86,3 @@ class StorageCloudFunctions {
     }
 }
 exports.StorageCloudFunctions = StorageCloudFunctions;
-//# sourceMappingURL=cloudFunctions.js.map

package/lib/emulator/storage/crc.js

@@ -31,4 +31,3 @@ function crc32cToString(crc32cValue) {
     return buffer.toString("base64");
 }
 exports.crc32cToString = crc32cToString;
-//# sourceMappingURL=crc.js.map

package/lib/emulator/storage/errors.js

@@ -7,4 +7,3 @@ exports.NotFoundError = NotFoundError;
 class ForbiddenError extends Error {
 }
 exports.ForbiddenError = ForbiddenError;
-//# sourceMappingURL=errors.js.map

package/lib/emulator/storage/files.js

@@ -401,4 +401,3 @@ function getPathSep(decodedPath) {
     const firstSepIndex = decodedPath.search(/[\/|\\\\]/g);
     return decodedPath[firstSepIndex];
 }
-//# sourceMappingURL=files.js.map

package/lib/emulator/storage/index.js

@@ -95,4 +95,3 @@ class StorageEmulator {
     }
 }
 exports.StorageEmulator = StorageEmulator;
-//# sourceMappingURL=index.js.map

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;
@@ -341,4 +347,3 @@ function generateETag(generation, metadatageneration) {
     hash.update(`${generation}/${metadatageneration}`);
     return hash.digest("base64").slice(0, -1);
 }
-//# sourceMappingURL=metadata.js.map