firebase-tools 11.20.0 → 11.22.0

package/lib/bin/firebase.js

@@ -8,7 +8,7 @@ if (!semver.satisfies(nodeVersion, pkg.engines.node)) {
     console.error(`Firebase CLI v${pkg.version} is incompatible with Node.js ${nodeVersion} Please upgrade Node.js to version ${pkg.engines.node}`);
     process.exit(1);
 }
-const updateNotifierPkg = require("update-notifier");
+const updateNotifierPkg = require("update-notifier-cjs");
 const clc = require("colorette");
 const TerminalRenderer = require("marked-terminal");
 const updateNotifier = updateNotifierPkg({ pkg });

package/lib/commands/appdistribution-distribute.js

@@ -90,6 +90,9 @@ exports.command = new command_1.Command("appdistribution:distribute <release-bin
             default:
                 utils.logSuccess(`uploaded release ${release.displayVersion} (${release.buildVersion}) successfully!`);
         }
+        utils.logSuccess(`View this release in the Firebase console: ${release.firebaseConsoleUri}`);
+        utils.logSuccess(`Share this release with testers who have access: ${release.testingUri}`);
+        utils.logSuccess(`Download the release binary (link expires in 1 hour): ${release.binaryDownloadUri}`);
         releaseName = uploadResponse.release.name;
     }
     catch (err) {

package/lib/commands/ext-configure.js

@@ -32,6 +32,7 @@ exports.command = new command_1.Command("ext:configure <extensionInstanceId>")
     .before(checkMinRequiredVersion_1.checkMinRequiredVersion, "extMinVersion")
     .before(extensionsHelper_1.diagnoseAndFixProject)
     .action(async (instanceId, options) => {
+    var _a;
     const projectId = (0, projectUtils_1.getProjectId)(options);
     if (options.nonInteractive) {
         throw new error_1.FirebaseError(`Command not supported in non-interactive mode, edit ./extensions/${instanceId}.env directly instead. ` +
@@ -56,7 +57,7 @@ exports.command = new command_1.Command("ext:configure <extensionInstanceId>")
         instanceId,
         projectDir: config.projectDir,
     });
-    const [immutableParams, tbdParams] = (0, functional_1.partition)(spec.params, (param) => { var _a; return (_a = param.immutable) !== null && _a !== void 0 ? _a : false; });
+    const [immutableParams, tbdParams] = (0, functional_1.partition)(spec.params.concat((_a = spec.systemParams) !== null && _a !== void 0 ? _a : []), (param) => { var _a; return (_a = param.immutable) !== null && _a !== void 0 ? _a : false; });
     infoImmutableParams(immutableParams, oldParamValues);
     paramHelper.setNewDefaults(tbdParams, oldParamValues);
     const mutableParamsBindingOptions = await paramHelper.getParams({

package/lib/commands/ext-install.js

@@ -120,7 +120,7 @@ async function infoExtensionVersion(args) {
     await (0, warnings_1.displayWarningPrompts)(ref.publisherId, extension.registryLaunchStage, args.extensionVersion);
 }
 async function installToManifest(options) {
-    var _a;
+    var _a, _b;
     const { projectId, extensionName, extVersion, source, paramsEnvPath, nonInteractive, force } = options;
     const isLocalSource = (0, extensionsHelper_1.isLocalPath)(extensionName);
     const spec = (_a = extVersion === null || extVersion === void 0 ? void 0 : extVersion.spec) !== null && _a !== void 0 ? _a : source === null || source === void 0 ? void 0 : source.spec;
@@ -134,7 +134,7 @@ async function installToManifest(options) {
     }
     const paramBindingOptions = await paramHelper.getParams({
         projectId,
-        paramSpecs: spec.params,
+        paramSpecs: spec.params.concat((_b = spec.systemParams) !== null && _b !== void 0 ? _b : []),
         nonInteractive,
         paramsEnvPath,
         instanceId,

package/lib/deploy/extensions/planner.js

@@ -8,7 +8,9 @@ const error_1 = require("../../error");
 const extensionsHelper_1 = require("../../extensions/extensionsHelper");
 const logger_1 = require("../../logger");
 const manifest_1 = require("../../extensions/manifest");
+const paramHelper_1 = require("../../extensions/paramHelper");
 const specHelper_1 = require("../../extensions/emulator/specHelper");
+const functional_1 = require("../../functional");
 async function getExtensionVersion(i) {
     if (!i.extensionVersion) {
         if (!i.ref) {
@@ -49,9 +51,11 @@ exports.getExtensionSpec = getExtensionSpec;
 async function have(projectId) {
     const instances = await extensionsApi.listInstances(projectId);
     return instances.map((i) => {
+        var _a;
         const dep = {
             instanceId: i.name.split("/").pop(),
             params: i.config.params,
+            systemParams: (_a = i.config.systemParams) !== null && _a !== void 0 ? _a : {},
             allowedEventTypes: i.config.allowedEventTypes,
             eventarcChannel: i.config.eventarcChannel,
             etag: i.etag,
@@ -71,7 +75,7 @@ async function want(args) {
     for (const e of Object.entries(args.extensions)) {
         try {
             const instanceId = e[0];
-            const params = (0, manifest_1.readInstanceParam)({
+            const rawParams = (0, manifest_1.readInstanceParam)({
                 projectDir: args.projectDir,
                 instanceId,
                 projectId: args.projectId,
@@ -80,18 +84,20 @@ async function want(args) {
                 checkLocal: args.emulatorMode,
             });
             const autoPopulatedParams = await (0, extensionsHelper_1.getFirebaseProjectParams)(args.projectId, args.emulatorMode);
-            const subbedParams = (0, extensionsHelper_1.substituteParams)(params, autoPopulatedParams);
-            const allowedEventTypes = subbedParams.ALLOWED_EVENT_TYPES !== undefined
-                ? subbedParams.ALLOWED_EVENT_TYPES.split(",").filter((e) => e !== "")
+            const subbedParams = (0, extensionsHelper_1.substituteParams)(rawParams, autoPopulatedParams);
+            const [systemParams, params] = (0, functional_1.partitionRecord)(subbedParams, paramHelper_1.isSystemParam);
+            const allowedEventTypes = params.ALLOWED_EVENT_TYPES !== undefined
+                ? params.ALLOWED_EVENT_TYPES.split(",").filter((e) => e !== "")
                 : undefined;
-            const eventarcChannel = subbedParams.EVENTARC_CHANNEL;
-            delete subbedParams["EVENTARC_CHANNEL"];
-            delete subbedParams["ALLOWED_EVENT_TYPES"];
+            const eventarcChannel = params.EVENTARC_CHANNEL;
+            delete params["EVENTARC_CHANNEL"];
+            delete params["ALLOWED_EVENT_TYPES"];
             if ((0, extensionsHelper_1.isLocalPath)(e[1])) {
                 instanceSpecs.push({
                     instanceId,
                     localPath: e[1],
-                    params: subbedParams,
+                    params,
+                    systemParams,
                     allowedEventTypes: allowedEventTypes,
                     eventarcChannel: eventarcChannel,
                 });
@@ -102,7 +108,8 @@ async function want(args) {
                 instanceSpecs.push({
                     instanceId,
                     ref,
-                    params: subbedParams,
+                    params,
+                    systemParams,
                     allowedEventTypes: allowedEventTypes,
                     eventarcChannel: eventarcChannel,
                 });

package/lib/deploy/extensions/tasks.js

@@ -32,6 +32,7 @@ function createExtensionInstanceTask(projectId, instanceSpec, validateOnly = fal
                 projectId,
                 instanceId: instanceSpec.instanceId,
                 params: instanceSpec.params,
+                systemParams: instanceSpec.systemParams,
                 extensionVersionRef: refs.toExtensionVersionRef(instanceSpec.ref),
                 allowedEventTypes: instanceSpec.allowedEventTypes,
                 eventarcChannel: instanceSpec.eventarcChannel,
@@ -44,6 +45,7 @@ function createExtensionInstanceTask(projectId, instanceSpec, validateOnly = fal
                 projectId,
                 instanceId: instanceSpec.instanceId,
                 params: instanceSpec.params,
+                systemParams: instanceSpec.systemParams,
                 extensionSource,
                 allowedEventTypes: instanceSpec.allowedEventTypes,
                 eventarcChannel: instanceSpec.eventarcChannel,
@@ -71,6 +73,7 @@ function updateExtensionInstanceTask(projectId, instanceSpec, validateOnly = fal
                 instanceId: instanceSpec.instanceId,
                 extRef: refs.toExtensionVersionRef(instanceSpec.ref),
                 params: instanceSpec.params,
+                systemParams: instanceSpec.systemParams,
                 canEmitEvents: !!instanceSpec.allowedEventTypes,
                 allowedEventTypes: instanceSpec.allowedEventTypes,
                 eventarcChannel: instanceSpec.eventarcChannel,
@@ -84,6 +87,8 @@ function updateExtensionInstanceTask(projectId, instanceSpec, validateOnly = fal
                 instanceId: instanceSpec.instanceId,
                 extensionSource,
                 validateOnly,
+                params: instanceSpec.params,
+                systemParams: instanceSpec.systemParams,
                 canEmitEvents: !!instanceSpec.allowedEventTypes,
                 allowedEventTypes: instanceSpec.allowedEventTypes,
                 eventarcChannel: instanceSpec.eventarcChannel,
@@ -109,6 +114,7 @@ function configureExtensionInstanceTask(projectId, instanceSpec, validateOnly =
                 projectId,
                 instanceId: instanceSpec.instanceId,
                 params: instanceSpec.params,
+                systemParams: instanceSpec.systemParams,
                 canEmitEvents: !!instanceSpec.allowedEventTypes,
                 allowedEventTypes: instanceSpec.allowedEventTypes,
                 eventarcChannel: instanceSpec.eventarcChannel,

package/lib/deploy/functions/prepareFunctionsUpload.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.prepareFunctionsUpload = exports.getFunctionsConfig = void 0;
+exports.convertToSortedKeyValueArray = exports.prepareFunctionsUpload = exports.getFunctionsConfig = void 0;
 const archiver = require("archiver");
 const clc = require("colorette");
 const filesize = require("filesize");
@@ -66,8 +66,9 @@ async function packageSource(sourceDir, config, runtimeConfig) {
             });
         }
         if (typeof runtimeConfig !== "undefined") {
+            const runtimeConfigHashString = JSON.stringify(convertToSortedKeyValueArray(runtimeConfig));
+            hashes.push(runtimeConfigHashString);
             const runtimeConfigString = JSON.stringify(runtimeConfig, null, 2);
-            hashes.push(runtimeConfigString);
             archive.append(runtimeConfigString, {
                 name: CONFIG_DEST_FILE,
                 mode: 420,
@@ -94,3 +95,13 @@ async function prepareFunctionsUpload(sourceDir, config, runtimeConfig) {
     return packageSource(sourceDir, config, runtimeConfig);
 }
 exports.prepareFunctionsUpload = prepareFunctionsUpload;
+function convertToSortedKeyValueArray(config) {
+    if (typeof config !== "object" || config === null)
+        return config;
+    return Object.keys(config)
+        .sort()
+        .map((key) => {
+        return { key, value: convertToSortedKeyValueArray(config[key]) };
+    });
+}
+exports.convertToSortedKeyValueArray = convertToSortedKeyValueArray;

package/lib/deploy/functions/runtimes/discovery/index.js

@@ -54,7 +54,7 @@ async function detectFromPort(port, project, runtime, timeout = 30000) {
     });
     while (true) {
         try {
-            res = await Promise.race([(0, node_fetch_1.default)(`http://localhost:${port}/__/functions.yaml`), timedOut]);
+            res = await Promise.race([(0, node_fetch_1.default)(`http://127.0.0.1:${port}/__/functions.yaml`), timedOut]);
             break;
         }
         catch (err) {

package/lib/deploy/functions/runtimes/index.js

@@ -2,10 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getRuntimeDelegate = exports.getHumanFriendlyRuntimeName = exports.isValidRuntime = exports.isDeprecatedRuntime = void 0;
 const node = require("./node");
+const python = require("./python");
 const validate = require("../validate");
 const error_1 = require("../../../error");
 const RUNTIMES = ["nodejs10", "nodejs12", "nodejs14", "nodejs16", "nodejs18"];
-const EXPERIMENTAL_RUNTIMES = ["go113"];
+const EXPERIMENTAL_RUNTIMES = ["python310", "python311"];
 const DEPRECATED_RUNTIMES = ["nodejs6", "nodejs8"];
 function isDeprecatedRuntime(runtime) {
     return DEPRECATED_RUNTIMES.includes(runtime);
@@ -23,13 +24,14 @@ const MESSAGE_FRIENDLY_RUNTIMES = {
     nodejs14: "Node.js 14",
     nodejs16: "Node.js 16",
     nodejs18: "Node.js 18",
-    go113: "Go 1.13",
+    python310: "Python 3.10",
+    python311: "Python 3.11 (Preview)",
 };
 function getHumanFriendlyRuntimeName(runtime) {
     return MESSAGE_FRIENDLY_RUNTIMES[runtime] || runtime;
 }
 exports.getHumanFriendlyRuntimeName = getHumanFriendlyRuntimeName;
-const factories = [node.tryCreateDelegate];
+const factories = [node.tryCreateDelegate, python.tryCreateDelegate];
 async function getRuntimeDelegate(context) {
     const { projectDir, sourceDir, runtime } = context;
     validate.functionsDirectoryExists(sourceDir, projectDir);

package/lib/deploy/functions/runtimes/node/index.js

@@ -16,6 +16,7 @@ const discovery = require("../discovery");
 const validate = require("./validate");
 const versioning = require("./versioning");
 const parseTriggers = require("./parseTriggers");
+const fsutils_1 = require("../../../../fsutils");
 const MIN_FUNCTIONS_SDK_VERSION = "3.20.0";
 async function tryCreateDelegate(context) {
     const packageJsonPath = path.join(context.sourceDir, "package.json");
@@ -39,6 +40,7 @@ class Delegate {
         this.runtime = runtime;
         this.name = "nodejs";
         this._sdkVersion = undefined;
+        this._bin = "";
     }
     get sdkVersion() {
         if (this._sdkVersion === undefined) {
@@ -46,6 +48,38 @@ class Delegate {
         }
         return this._sdkVersion;
     }
+    get bin() {
+        if (this._bin === "") {
+            this._bin = this.getNodeBinary();
+        }
+        return this._bin;
+    }
+    getNodeBinary() {
+        const requestedVersion = semver.coerce(this.runtime);
+        if (!requestedVersion) {
+            throw new error_1.FirebaseError(`Could not determine version of the requested runtime: ${this.runtime}`);
+        }
+        const hostVersion = process.versions.node;
+        const localNodePath = path.join(this.sourceDir, "node_modules/node");
+        const localNodeVersion = versioning.findModuleVersion("node", localNodePath);
+        if (localNodeVersion) {
+            if (semver.major(requestedVersion) === semver.major(localNodeVersion)) {
+                (0, utils_1.logLabeledSuccess)("functions", `Using node@${semver.major(localNodeVersion)} from local cache.`);
+                return localNodePath;
+            }
+        }
+        if (semver.major(requestedVersion) === semver.major(hostVersion)) {
+            (0, utils_1.logLabeledSuccess)("functions", `Using node@${semver.major(hostVersion)} from host.`);
+            return process.execPath;
+        }
+        if (!process.env.FIREPIT_VERSION) {
+            (0, utils_1.logLabeledWarning)("functions", `Your requested "node" version "${semver.major(requestedVersion)}" doesn't match your global version "${semver.major(hostVersion)}". Using node@${semver.major(hostVersion)} from host.`);
+            return process.execPath;
+        }
+        (0, utils_1.logLabeledWarning)("functions", `You've requested "node" version "${semver.major(requestedVersion)}", but the standalone Firebase CLI comes with bundled Node "${semver.major(hostVersion)}".`);
+        (0, utils_1.logLabeledSuccess)("functions", `To use a different Node.js version, consider removing the standalone Firebase CLI and switching to "firebase-tools" on npm.`);
+        return process.execPath;
+    }
     validate() {
         versioning.checkFunctionsSDKVersion(this.sdkVersion);
         const relativeDir = path.relative(this.projectDir, this.sourceDir);
@@ -57,33 +91,44 @@ class Delegate {
     watch() {
         return Promise.resolve(() => Promise.resolve());
     }
-    serve(port, config, envs) {
+    serveAdmin(port, config, envs) {
         var _a;
-        const env = Object.assign(Object.assign({}, envs), { PORT: port.toString(), FUNCTIONS_CONTROL_API: "true", HOME: process.env.HOME, PATH: process.env.PATH, NODE_ENV: process.env.NODE_ENV });
+        const env = Object.assign(Object.assign({}, envs), { PORT: port, FUNCTIONS_CONTROL_API: "true", HOME: process.env.HOME, PATH: process.env.PATH, NODE_ENV: process.env.NODE_ENV });
         if (Object.keys(config || {}).length) {
             env.CLOUD_RUNTIME_CONFIG = JSON.stringify(config);
         }
-        const childProcess = spawn("./node_modules/.bin/firebase-functions", [this.sourceDir], {
-            env,
-            cwd: this.sourceDir,
-            stdio: ["ignore", "pipe", "inherit"],
-        });
-        (_a = childProcess.stdout) === null || _a === void 0 ? void 0 : _a.on("data", (chunk) => {
-            logger_1.logger.debug(chunk.toString());
-        });
-        return Promise.resolve(async () => {
-            const p = new Promise((resolve, reject) => {
-                childProcess.once("exit", resolve);
-                childProcess.once("error", reject);
-            });
-            await (0, node_fetch_1.default)(`http://localhost:${port}/__/quitquitquit`);
-            setTimeout(() => {
-                if (!childProcess.killed) {
-                    childProcess.kill("SIGKILL");
-                }
-            }, 10000);
-            return p;
-        });
+        const sourceNodeModulesPath = path.join(this.sourceDir, "node_modules");
+        const sdkPath = require.resolve("firebase-functions", { paths: [this.sourceDir] });
+        const sdkNodeModulesPath = sdkPath.substring(0, sdkPath.lastIndexOf("node_modules") + 12);
+        for (const nodeModulesPath of [sourceNodeModulesPath, sdkNodeModulesPath]) {
+            const binPath = path.join(nodeModulesPath, ".bin", "firebase-functions");
+            if ((0, fsutils_1.fileExistsSync)(binPath)) {
+                logger_1.logger.debug(`Found firebase-functions binary at '${binPath}'`);
+                const childProcess = spawn(binPath, [this.sourceDir], {
+                    env,
+                    cwd: this.sourceDir,
+                    stdio: ["ignore", "pipe", "inherit"],
+                });
+                (_a = childProcess.stdout) === null || _a === void 0 ? void 0 : _a.on("data", (chunk) => {
+                    logger_1.logger.debug(chunk.toString());
+                });
+                return Promise.resolve(async () => {
+                    const p = new Promise((resolve, reject) => {
+                        childProcess.once("exit", resolve);
+                        childProcess.once("error", reject);
+                    });
+                    await (0, node_fetch_1.default)(`http://localhost:${port}/__/quitquitquit`);
+                    setTimeout(() => {
+                        if (!childProcess.killed) {
+                            childProcess.kill("SIGKILL");
+                        }
+                    }, 10000);
+                    return p;
+                });
+            }
+        }
+        throw new error_1.FirebaseError("Failed to find location of Firebase Functions SDK. " +
+            "Please file a bug on Github (https://github.com/firebase/firebase-tools/).");
     }
     async discoverBuild(config, env) {
         if (!semver.valid(this.sdkVersion)) {
@@ -97,9 +142,9 @@ class Delegate {
         }
         let discovered = await discovery.detectFromYaml(this.sourceDir, this.projectId, this.runtime);
         if (!discovered) {
-            const getPort = (0, util_1.promisify)(portfinder.getPort);
-            const port = await getPort();
-            const kill = await this.serve(port, config, env);
+            const basePort = 8000 + (0, utils_1.randomInt)(0, 1000);
+            const port = await portfinder.getPortPromise({ port: basePort });
+            const kill = await this.serveAdmin(port.toString(), config, env);
             try {
                 discovered = await discovery.detectFromPort(port, this.projectId, this.runtime);
             }

package/lib/deploy/functions/runtimes/node/versioning.js

@@ -4,12 +4,13 @@ exports.checkFunctionsSDKVersion = exports.getLatestSDKVersion = exports.getFunc
 const fs = require("fs");
 const path = require("path");
 const clc = require("colorette");
-const semver = require("semver");
 const spawn = require("cross-spawn");
-const utils = require("../../../../utils");
+const semver = require("semver");
 const logger_1 = require("../../../../logger");
 const track_1 = require("../../../../track");
+const utils = require("../../../../utils");
 const MIN_SDK_VERSION = "2.0.0";
+const NPM_COMMAND_TIMEOUT_MILLIES = 10000;
 exports.FUNCTIONS_SDK_VERSION_TOO_OLD_WARNING = clc.bold(clc.yellow("functions: ")) +
     "You must have a " +
     clc.bold("firebase-functions") +
@@ -53,6 +54,7 @@ function getLatestSDKVersion() {
     var _a;
     const child = spawn.sync("npm", ["show", "firebase-functions", "--json=true"], {
         encoding: "utf8",
+        timeout: NPM_COMMAND_TIMEOUT_MILLIES,
     });
     if (child.error) {
         logger_1.logger.debug("checkFunctionsSDKVersion was unable to fetch information from NPM", child.error.stack);

package/lib/deploy/functions/runtimes/python/index.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Delegate = exports.tryCreateDelegate = void 0;
+const fs = require("fs");
+const path = require("path");
+const node_fetch_1 = require("node-fetch");
+const util_1 = require("util");
+const portfinder = require("portfinder");
+const runtimes = require("..");
+const discovery = require("../discovery");
+const logger_1 = require("../../../../logger");
+const python_1 = require("../../../../functions/python");
+const error_1 = require("../../../../error");
+const LATEST_VERSION = "python310";
+async function tryCreateDelegate(context) {
+    const requirementsTextPath = path.join(context.sourceDir, "requirements.txt");
+    if (!(await (0, util_1.promisify)(fs.exists)(requirementsTextPath))) {
+        logger_1.logger.debug("Customer code is not Python code.");
+        return;
+    }
+    const runtime = context.runtime ? context.runtime : LATEST_VERSION;
+    if (!runtimes.isValidRuntime(runtime)) {
+        throw new error_1.FirebaseError(`Runtime ${runtime} is not a valid Python runtime`);
+    }
+    return Promise.resolve(new Delegate(context.projectId, context.sourceDir, runtime));
+}
+exports.tryCreateDelegate = tryCreateDelegate;
+class Delegate {
+    constructor(projectId, sourceDir, runtime) {
+        this.projectId = projectId;
+        this.sourceDir = sourceDir;
+        this.runtime = runtime;
+        this.name = "python";
+        this._bin = "";
+        this._modulesDir = "";
+    }
+    get bin() {
+        if (this._bin === "") {
+            this._bin = this.getPythonBinary();
+        }
+        return this._bin;
+    }
+    async modulesDir() {
+        var _a;
+        if (!this._modulesDir) {
+            const child = (0, python_1.runWithVirtualEnv)([
+                this.bin,
+                "-c",
+                '"import firebase_functions; import os; print(os.path.dirname(firebase_functions.__file__))"',
+            ], this.sourceDir, {});
+            let out = "";
+            (_a = child.stdout) === null || _a === void 0 ? void 0 : _a.on("data", (chunk) => {
+                const chunkString = chunk.toString();
+                out = out + chunkString;
+                logger_1.logger.debug(`stdout: ${chunkString}`);
+            });
+            await new Promise((resolve, reject) => {
+                child.on("exit", resolve);
+                child.on("error", reject);
+            });
+            this._modulesDir = out.trim();
+        }
+        return this._modulesDir;
+    }
+    getPythonBinary() {
+        if (process.platform === "win32") {
+            return "python.exe";
+        }
+        if (this.runtime === "python310") {
+            return "python3.10";
+        }
+        else if (this.runtime === "python311") {
+            return "python3.11";
+        }
+        return "python";
+    }
+    validate() {
+        return Promise.resolve();
+    }
+    watch() {
+        return Promise.resolve(() => Promise.resolve());
+    }
+    async build() {
+        return Promise.resolve();
+    }
+    async serveAdmin(port, envs) {
+        const modulesDir = await this.modulesDir();
+        const envWithAdminPort = Object.assign(Object.assign({}, envs), { ADMIN_PORT: port.toString() });
+        const args = [this.bin, path.join(modulesDir, "private", "serving.py")];
+        logger_1.logger.debug(`Running admin server with args: ${JSON.stringify(args)} and env: ${JSON.stringify(envWithAdminPort)} in ${this.sourceDir}`);
+        const childProcess = (0, python_1.runWithVirtualEnv)(args, this.sourceDir, envWithAdminPort);
+        return Promise.resolve(async () => {
+            await (0, node_fetch_1.default)(`http://127.0.0.1:${port}/__/quitquitquit`);
+            const quitTimeout = setTimeout(() => {
+                if (!childProcess.killed) {
+                    childProcess.kill("SIGKILL");
+                }
+            }, 10000);
+            clearTimeout(quitTimeout);
+        });
+    }
+    async discoverBuild(_configValues, envs) {
+        let discovered = await discovery.detectFromYaml(this.sourceDir, this.projectId, this.runtime);
+        if (!discovered) {
+            const adminPort = await portfinder.getPortPromise({
+                port: 8081,
+            });
+            const killProcess = await this.serveAdmin(adminPort, envs);
+            try {
+                discovered = await discovery.detectFromPort(adminPort, this.projectId, this.runtime);
+            }
+            finally {
+                await killProcess();
+            }
+        }
+        return discovered;
+    }
+}
+exports.Delegate = Delegate;

package/lib/emulator/auth/apiSpec.js

@@ -4562,6 +4562,10 @@ exports.default = {
                 description: "Response message for GetRecaptchaParam.",
                 properties: {
                     kind: { type: "string" },
+                    producerProjectNumber: {
+                        description: "The producer project number used to generate PIA tokens",
+                        type: "string",
+                    },
                     recaptchaSiteKey: {
                         description: "The reCAPTCHA v2 site key used to invoke the reCAPTCHA service. Always present.",
                         type: "string",

package/lib/emulator/auth/operations.js

@@ -502,7 +502,7 @@ function createSessionCookie(state, reqBody) {
     const { payload } = parseIdToken(state, reqBody.idToken);
     const issuedAt = (0, utils_1.toUnixTimestamp)(new Date());
     const expiresAt = issuedAt + validDuration;
-    const sessionCookie = (0, jsonwebtoken_1.sign)(Object.assign(Object.assign({}, payload), { iat: issuedAt, exp: expiresAt, iss: `https://session.firebase.google.com/${payload.aud}` }), "", {
+    const sessionCookie = (0, jsonwebtoken_1.sign)(Object.assign(Object.assign({}, payload), { iat: issuedAt, exp: expiresAt, iss: `https://session.firebase.google.com/${payload.aud}` }), "fake-secret", {
         algorithm: "none",
     });
     return { sessionCookie };
@@ -1552,7 +1552,7 @@ function generateJwt(user, { projectId, signInProvider, expiresInSeconds, extraC
             tenant: tenantId,
             sign_in_attributes: signInAttributes,
         } });
-    const jwtStr = (0, jsonwebtoken_1.sign)(customPayloadFields, "", {
+    const jwtStr = (0, jsonwebtoken_1.sign)(customPayloadFields, "fake-secret", {
         algorithm: "none",
         expiresIn: expiresInSeconds,
         subject: user.localId,
@@ -2129,7 +2129,7 @@ function generateBlockingFunctionJwt(state, event, url, timeoutMs, user, options
     if (state.shouldForwardCredentialToBlockingFunction("refreshToken")) {
         jwt.oauth_refresh_token = oauthTokens.oauthRefreshToken;
     }
-    const jwtStr = (0, jsonwebtoken_1.sign)(jwt, "", {
+    const jwtStr = (0, jsonwebtoken_1.sign)(jwt, "fake-secret", {
         algorithm: "none",
     });
     return jwtStr;

package/lib/emulator/controller.js

@@ -11,7 +11,6 @@ const registry_1 = require("./registry");
 const types_1 = require("./types");
 const constants_1 = require("./constants");
 const functionsEmulator_1 = require("./functionsEmulator");
-const functionsEmulatorUtils_1 = require("./functionsEmulatorUtils");
 const auth_1 = require("./auth");
 const databaseEmulator_1 = require("./databaseEmulator");
 const firestoreEmulator_1 = require("./firestoreEmulator");
@@ -152,7 +151,7 @@ function findExportMetadata(importPath) {
     }
 }
 async function startAll(options, showUI = true) {
-    var _a, _b, _c, _d, _e, _f, _g;
+    var _a, _b, _c, _d, _e, _f, _g, _h;
     const targets = filterEmulatorTargets(options);
     options.targets = targets;
     const singleProjectModeEnabled = ((_a = options.config.src.emulators) === null || _a === void 0 ? void 0 : _a.singleProjectMode) === undefined ||
@@ -301,13 +300,14 @@ async function startAll(options, showUI = true) {
         utils.assertIsStringOrUndefined(options.extDevDir);
         for (const cfg of functionsCfg) {
             const functionsDir = path.join(projectDir, cfg.source);
+            const runtime = (_e = options.extDevRuntime) !== null && _e !== void 0 ? _e : cfg.runtime;
             emulatableBackends.push({
                 functionsDir,
+                runtime,
                 codebase: cfg.codebase,
                 env: Object.assign({}, options.extDevEnv),
                 secretEnv: [],
                 predefinedTriggers: options.extDevTriggers,
-                nodeMajorVersion: (0, functionsEmulatorUtils_1.parseRuntimeVersion)(options.extDevNodeVersion || cfg.runtime),
             });
         }
     }
@@ -316,7 +316,7 @@ async function startAll(options, showUI = true) {
     }
     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) }));
+            listenForEmulator = await (0, portUtils_1.resolveHostAndAssignPorts)(Object.assign(Object.assign({}, listenForEmulator), { functions: (_f = listenForEmulator.functions) !== null && _f !== void 0 ? _f : getListenConfig(options, types_1.Emulators.FUNCTIONS), eventarc: (_g = listenForEmulator.eventarc) !== null && _g !== void 0 ? _g : getListenConfig(options, types_1.Emulators.EVENTARC) }));
             hubLogger.log("DEBUG", "late-assigned ports for functions and eventarc emulators", {
                 user: listenForEmulator,
             });
@@ -377,7 +377,7 @@ async function startAll(options, showUI = true) {
             });
         }
         const config = options.config;
-        const rulesLocalPath = (_g = config.src.firestore) === null || _g === void 0 ? void 0 : _g.rules;
+        const rulesLocalPath = (_h = config.src.firestore) === null || _h === void 0 ? void 0 : _h.rules;
         let rulesFileFound = false;
         if (rulesLocalPath) {
             const rules = config.path(rulesLocalPath);

package/lib/emulator/downloadableEmulators.js

@@ -28,9 +28,9 @@ const EMULATOR_UPDATE_DETAILS = {
         expectedChecksum: "4f41d24a3c0f3b55ea22804a424cc0ee",
     },
     storage: {
-        version: "1.1.2",
-        expectedSize: 47028740,
-        expectedChecksum: "983b4415b1e72b109864f1b8e7ea7546",
+        version: "1.1.3",
+        expectedSize: 52892936,
+        expectedChecksum: "2ca11ec1193003bea89f806cc085fa25",
     },
     ui: experiments.isEnabled("emulatoruisnapshot")
         ? { version: "SNAPSHOT", expectedSize: -1, expectedChecksum: "" }

package/lib/emulator/extensionsEmulator.js

@@ -143,14 +143,15 @@ class ExtensionsEmulator {
         const extensionDir = await this.ensureSourceCode(instance);
         const functionsDir = path.join(extensionDir, "functions");
         const env = Object.assign(this.autoPopulatedParams(instance), instance.params);
-        const { extensionTriggers, nodeMajorVersion, nonSecretEnv, secretEnvVariables } = await (0, optionsHelper_1.getExtensionFunctionInfo)(instance, env);
+        const { extensionTriggers, runtime, nonSecretEnv, secretEnvVariables } = await (0, optionsHelper_1.getExtensionFunctionInfo)(instance, env);
         const emulatableBackend = {
             functionsDir,
+            runtime,
+            bin: process.execPath,
             env: nonSecretEnv,
             codebase: instance.instanceId,
             secretEnv: secretEnvVariables,
             predefinedTriggers: extensionTriggers,
-            nodeMajorVersion: nodeMajorVersion,
             extensionInstanceId: instance.instanceId,
         };
         if (instance.ref) {