firebase-tools 11.21.0 → 11.22.0

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 = [];
+const EXPERIMENTAL_RUNTIMES = ["python310", "python311"];
 const DEPRECATED_RUNTIMES = ["nodejs6", "nodejs8"];
 function isDeprecatedRuntime(runtime) {
     return DEPRECATED_RUNTIMES.includes(runtime);
@@ -23,12 +24,14 @@ const MESSAGE_FRIENDLY_RUNTIMES = {
     nodejs14: "Node.js 14",
     nodejs16: "Node.js 16",
     nodejs18: "Node.js 18",
+    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,35 +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 sourceNodeModulesPath = path.join(this.sourceDir, "node_modules");
         const sdkPath = require.resolve("firebase-functions", { paths: [this.sourceDir] });
-        const binPath = sdkPath.substring(0, sdkPath.lastIndexOf("node_modules") + 12);
-        const childProcess = spawn(path.join(binPath, ".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 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)) {
@@ -99,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/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/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) {