firebase-tools 10.1.5 → 10.2.0

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

@@ -56,6 +56,7 @@ function parseEndpoints(manifest, id, project, defaultRegion, runtime) {
         labels: "object",
         ingressSettings: "string",
         environmentVariables: "object",
+        secretEnvironmentVariables: "array",
         httpsTrigger: "object",
         eventTrigger: "object",
         scheduleTrigger: "object",

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

@@ -107,6 +107,18 @@ function addResourcesToBackend(projectId, runtime, annotation, want) {
             }
             endpoint.vpcConnector = maybeId;
         }
+        if (annotation.secrets) {
+            const secretEnvs = [];
+            for (const secret of annotation.secrets) {
+                const secretEnv = {
+                    secret,
+                    projectId,
+                    key: secret,
+                };
+                secretEnvs.push(secretEnv);
+            }
+            endpoint.secretEnvironmentVariables = secretEnvs;
+        }
         proto.copyIfPresent(endpoint, annotation, "concurrency", "serviceAccountEmail", "labels", "vpcConnectorEgressSettings", "ingressSettings", "timeout", "maxInstances", "minInstances", "availableMemoryMb");
         want.endpoints[region] = want.endpoints[region] || {};
         want.endpoints[region][endpoint.id] = endpoint;

package/lib/deploy/functions/validate.js

@@ -1,11 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.functionIdsAreValid = exports.functionsDirectoryExists = exports.endpointsAreValid = void 0;
+exports.secretsAreValid = exports.functionIdsAreValid = exports.functionsDirectoryExists = exports.endpointsAreValid = void 0;
 const path = require("path");
 const clc = require("cli-color");
 const error_1 = require("../../error");
+const secretManager_1 = require("../../gcp/secretManager");
+const logger_1 = require("../../logger");
 const fsutils = require("../../fsutils");
 const backend = require("./backend");
+const utils = require("../../utils");
+const secrets = require("../../functions/secrets");
 function endpointsAreValid(wantBackend) {
     functionIdsAreValid(backend.allEndpoints(wantBackend));
     const gcfV1WithConcurrency = backend
@@ -62,3 +66,54 @@ function functionIdsAreValid(functions) {
     }
 }
 exports.functionIdsAreValid = functionIdsAreValid;
+async function secretsAreValid(projectId, wantBackend) {
+    const endpoints = backend
+        .allEndpoints(wantBackend)
+        .filter((e) => e.secretEnvironmentVariables && e.secretEnvironmentVariables.length > 0);
+    validatePlatformTargets(endpoints);
+    await validateSecretVersions(projectId, endpoints);
+}
+exports.secretsAreValid = secretsAreValid;
+function validatePlatformTargets(endpoints) {
+    const supportedPlatforms = ["gcfv1"];
+    const unsupported = endpoints.filter((e) => !supportedPlatforms.includes(e.platform));
+    if (unsupported.length > 0) {
+        const errs = unsupported.map((e) => `${e.id}[platform=${e.platform}]`);
+        throw new error_1.FirebaseError(`Tried to set secret environment variables on ${errs.join(", ")}. ` +
+            `Only ${supportedPlatforms.join(", ")} support secret environments.`);
+    }
+}
+async function validateSecretVersions(projectId, endpoints) {
+    const toResolve = new Set();
+    for (const s of secrets.of(endpoints)) {
+        toResolve.add(s.secret);
+    }
+    const results = await utils.allSettled(Array.from(toResolve).map(async (secret) => {
+        const sv = await (0, secretManager_1.getSecretVersion)(projectId, secret, "latest");
+        logger_1.logger.debug(`Resolved secret version of ${clc.bold(secret)} to ${clc.bold(sv.versionId)}.`);
+        return sv;
+    }));
+    const secretVersions = {};
+    const errs = [];
+    for (const result of results) {
+        if (result.status === "fulfilled") {
+            const sv = result.value;
+            if (sv.state != "ENABLED") {
+                errs.push(new error_1.FirebaseError(`Expected secret ${sv.secret.name}@${sv.versionId} to be in state ENABLED not ${sv.state}.`));
+            }
+            secretVersions[sv.secret.name] = sv;
+        }
+        else {
+            errs.push(new error_1.FirebaseError(result.reason.message));
+        }
+    }
+    if (errs.length) {
+        throw new error_1.FirebaseError("Failed to validate secret versions", { children: errs });
+    }
+    for (const s of secrets.of(endpoints)) {
+        s.version = secretVersions[s.secret].versionId;
+        if (!s.version) {
+            throw new error_1.FirebaseError("Secret version is unexpectedly undefined. This should never happen.");
+        }
+    }
+}

package/lib/emulator/controller.js

@@ -246,7 +246,8 @@ async function startAll(options, showUI = true) {
         utils.assertDefined(options.config.src.functions);
         utils.assertDefined(options.config.src.functions.source, "Error: 'functions.source' is not defined");
         utils.assertIsStringOrUndefined(options.extensionDir);
-        const functionsDir = path.join(options.extensionDir || options.config.projectDir, options.config.src.functions.source);
+        const projectDir = options.extensionDir || options.config.projectDir;
+        const functionsDir = path.join(projectDir, options.config.src.functions.source);
         let inspectFunctions;
         if (options.inspectFunctions) {
             inspectFunctions = commandUtils.parseInspectionPort(options);
@@ -269,6 +270,7 @@ async function startAll(options, showUI = true) {
         ];
         const functionsEmulator = new functionsEmulator_1.FunctionsEmulator({
             projectId,
+            projectDir,
             emulatableBackends,
             account,
             host: functionsAddr.host,

package/lib/emulator/emulatorLogger.js

@@ -13,6 +13,7 @@ const TYPE_VERBOSITY = {
     USER: 2,
     WARN: 2,
     WARN_ONCE: 2,
+    ERROR: 2,
 };
 var Verbosity;
 (function (Verbosity) {
@@ -79,6 +80,9 @@ class EmulatorLogger {
             case "SUCCESS":
                 utils.logSuccess(text, "info", mergedData);
                 break;
+            case "ERROR":
+                utils.logBullet(text, "error", mergedData);
+                break;
         }
     }
     handleRuntimeLog(log, ignore = []) {
@@ -196,6 +200,9 @@ You can probably fix this by running "npm install ${systemLog.data.name}@latest"
                     EmulatorLogger.warnOnceCache.add(text);
                 }
                 break;
+            case "ERROR":
+                utils.logLabeledError(label, text, "error", mergedData);
+                break;
         }
     }
     static shouldSupress(type) {

package/lib/emulator/functionsEmulator.js

@@ -27,10 +27,14 @@ const workQueue_1 = require("./workQueue");
 const utils_1 = require("../utils");
 const defaultCredentials_1 = require("../defaultCredentials");
 const adminSdkConfig_1 = require("./adminSdkConfig");
-const functionsEnv = require("../functions/env");
 const types_2 = require("./events/types");
 const validate_1 = require("../deploy/functions/validate");
+const runtimes_1 = require("../deploy/functions/runtimes");
+const backend = require("../deploy/functions/backend");
+const functionsEnv = require("../functions/env");
+const secretManager_1 = require("../gcp/secretManager");
 const EVENT_INVOKE = "functions:invoke";
+const LOCAL_SECRETS_FILE = ".secret.local";
 const DATABASE_PATH_PATTERN = new RegExp("^projects/[^/]+/instances/([^/]+)/refs(/.*)$");
 class FunctionsEmulator {
     constructor(args) {
@@ -44,9 +48,7 @@ class FunctionsEmulator {
             this.args.disabledRuntimeFeatures = this.args.disabledRuntimeFeatures || {};
             this.args.disabledRuntimeFeatures.timeout = true;
         }
-        this.adminSdkConfig = {
-            projectId: this.args.projectId,
-        };
+        this.adminSdkConfig = Object.assign(Object.assign({}, this.args.adminSdkConfig), { projectId: this.args.projectId });
         const mode = this.args.debugPort
             ? types_1.FunctionsExecutionMode.SEQUENTIAL
             : types_1.FunctionsExecutionMode.AUTO;
@@ -159,25 +161,17 @@ class FunctionsEmulator {
         });
         return hub;
     }
-    startFunctionRuntime(backend, triggerId, targetName, signatureType, proto, runtimeOpts) {
-        const bundleTemplate = this.getBaseBundle(backend);
-        const runtimeBundle = Object.assign(Object.assign({}, bundleTemplate), { emulators: {
-                firestore: this.getEmulatorInfo(types_1.Emulators.FIRESTORE),
-                database: this.getEmulatorInfo(types_1.Emulators.DATABASE),
-                pubsub: this.getEmulatorInfo(types_1.Emulators.PUBSUB),
-                auth: this.getEmulatorInfo(types_1.Emulators.AUTH),
-                storage: this.getEmulatorInfo(types_1.Emulators.STORAGE),
-            }, nodeMajorVersion: backend.nodeMajorVersion, proto,
-            triggerId,
-            targetName });
+    async startFunctionRuntime(backend, trigger, proto, runtimeOpts) {
+        const bundleTemplate = this.getBaseBundle();
+        const runtimeBundle = Object.assign(Object.assign({}, bundleTemplate), { proto });
         if (!backend.nodeBinary) {
-            throw new error_1.FirebaseError(`No node binary for ${triggerId}. This should never happen.`);
+            throw new error_1.FirebaseError(`No node binary for ${trigger.id}. This should never happen.`);
         }
         const opts = runtimeOpts || {
             nodeBinary: backend.nodeBinary,
             extensionTriggers: backend.predefinedTriggers,
         };
-        const worker = this.invokeRuntime(runtimeBundle, opts, this.getRuntimeEnvs(backend, { targetName, signatureType }));
+        const worker = await this.invokeRuntime(backend, trigger, runtimeBundle, opts);
         return worker;
     }
     async start() {
@@ -188,13 +182,15 @@ class FunctionsEmulator {
         for (const e of this.args.emulatableBackends) {
             e.env = Object.assign(Object.assign({}, credentialEnv), e.env);
         }
-        const adminSdkConfig = await (0, adminSdkConfig_1.getProjectAdminSdkConfigOrCached)(this.args.projectId);
-        if (adminSdkConfig) {
-            this.adminSdkConfig = adminSdkConfig;
-        }
-        else {
-            this.logger.logLabeled("WARN", "functions", "Unable to fetch project Admin SDK configuration, Admin SDK behavior in Cloud Functions emulator may be incorrect.");
-            this.adminSdkConfig = (0, adminSdkConfig_1.constructDefaultAdminSdkConfig)(this.args.projectId);
+        if (Object.keys(this.adminSdkConfig || {}).length <= 1) {
+            const adminSdkConfig = await (0, adminSdkConfig_1.getProjectAdminSdkConfigOrCached)(this.args.projectId);
+            if (adminSdkConfig) {
+                this.adminSdkConfig = adminSdkConfig;
+            }
+            else {
+                this.logger.logLabeled("WARN", "functions", "Unable to fetch project Admin SDK configuration, Admin SDK behavior in Cloud Functions emulator may be incorrect.");
+                this.adminSdkConfig = (0, adminSdkConfig_1.constructDefaultAdminSdkConfig)(this.args.projectId);
+            }
         }
         const { host, port } = this.getInfo();
         this.workQueue.start();
@@ -242,14 +238,25 @@ class FunctionsEmulator {
         if (!emulatableBackend.nodeBinary) {
             throw new error_1.FirebaseError(`No node binary for ${emulatableBackend.functionsDir}. This should never happen.`);
         }
-        const worker = this.invokeRuntime(this.getBaseBundle(emulatableBackend), {
-            nodeBinary: emulatableBackend.nodeBinary,
-            extensionTriggers: emulatableBackend.predefinedTriggers,
-        }, Object.assign(Object.assign(Object.assign(Object.assign({}, this.getSystemEnvs()), this.getEmulatorEnvs()), { FIREBASE_CONFIG: this.getFirebaseConfig() }), emulatableBackend.env));
-        const triggerParseEvent = await types_1.EmulatorLog.waitForLog(worker.runtime.events, "SYSTEM", "triggers-parsed");
-        const parsedDefinitions = triggerParseEvent.data
-            .triggerDefinitions;
-        const triggerDefinitions = (0, functionsEmulatorShared_1.emulatedFunctionsByRegion)(parsedDefinitions);
+        let triggerDefinitions;
+        if (emulatableBackend.predefinedTriggers) {
+            triggerDefinitions = (0, functionsEmulatorShared_1.emulatedFunctionsByRegion)(emulatableBackend.predefinedTriggers);
+        }
+        else {
+            const runtimeDelegate = await (0, runtimes_1.getRuntimeDelegate)({
+                projectId: this.args.projectId,
+                projectDir: this.args.projectDir,
+                sourceDir: emulatableBackend.functionsDir,
+            });
+            logger_1.logger.debug(`Validating ${runtimeDelegate.name} source`);
+            await runtimeDelegate.validate();
+            logger_1.logger.debug(`Building ${runtimeDelegate.name} source`);
+            await runtimeDelegate.build();
+            logger_1.logger.debug(`Analyzing ${runtimeDelegate.name} backend spec`);
+            const discoveredBackend = await runtimeDelegate.discoverSpec({}, Object.assign(Object.assign(Object.assign(Object.assign({}, this.getSystemEnvs()), this.getEmulatorEnvs()), { FIREBASE_CONFIG: this.getFirebaseConfig() }), emulatableBackend.env));
+            const endpoints = backend.allEndpoints(discoveredBackend);
+            triggerDefinitions = (0, functionsEmulatorShared_1.emulatedFunctionsFromEndpoints)(endpoints);
+        }
         const toSetup = triggerDefinitions.filter((definition) => {
             if (force) {
                 return true;
@@ -305,7 +312,7 @@ class FunctionsEmulator {
                 }
             }
             else {
-                this.logger.log("WARN", `Trigger trigger "${definition.name}" has has neither "httpsTrigger" or "eventTrigger" member`);
+                this.logger.log("WARN", `Unsupported function type on ${definition.name}. Expected either httpsTrigger or eventTrigger.`);
             }
             const ignored = !added;
             this.addTriggerRecord(definition, { backend: emulatableBackend, ignored, url });
@@ -331,7 +338,7 @@ class FunctionsEmulator {
         }
         const result = DATABASE_PATH_PATTERN.exec(eventTrigger.resource);
         if (result === null || result.length !== 3) {
-            this.logger.log("WARN", `Event trigger "${key}" has malformed "resource" member. ` + `${eventTrigger.resource}`);
+            this.logger.log("WARN", `Event function "${key}" has malformed "resource" member. ` + `${eventTrigger.resource}`);
             return Promise.reject();
         }
         const instance = result[1];
@@ -347,7 +354,7 @@ class FunctionsEmulator {
             setTriggersPath += `?ns=${instance}`;
         }
         else {
-            this.logger.log("WARN", `No project in use. Registering function trigger for sentinel namespace '${constants_1.Constants.DEFAULT_DATABASE_EMULATOR_NAMESPACE}'`);
+            this.logger.log("WARN", `No project in use. Registering function for sentinel namespace '${constants_1.Constants.DEFAULT_DATABASE_EMULATOR_NAMESPACE}'`);
         }
         return api
             .request("POST", setTriggersPath, {
@@ -362,7 +369,7 @@ class FunctionsEmulator {
             return true;
         })
             .catch((err) => {
-            this.logger.log("WARN", "Error adding trigger: " + err);
+            this.logger.log("WARN", "Error adding Realtime Database function: " + err);
             throw err;
         });
     }
@@ -371,7 +378,9 @@ class FunctionsEmulator {
         if (!firestoreEmu) {
             return Promise.resolve(false);
         }
-        const bundle = JSON.stringify({ eventTrigger });
+        const bundle = JSON.stringify({
+            eventTrigger: Object.assign(Object.assign({}, eventTrigger), { service: "firestore.googleapis.com" }),
+        });
         logger_1.logger.debug(`addFirestoreTrigger`, JSON.stringify(bundle));
         return api
             .request("PUT", `/emulator/v1/projects/${projectId}/triggers/${key}`, {
@@ -383,7 +392,7 @@ class FunctionsEmulator {
             return true;
         })
             .catch((err) => {
-            this.logger.log("WARN", "Error adding trigger: " + err);
+            this.logger.log("WARN", "Error adding firestore function: " + err);
             throw err;
         });
     }
@@ -452,7 +461,7 @@ class FunctionsEmulator {
         const record = this.triggers[triggerKey];
         if (!record) {
             logger_1.logger.debug(`Could not find key=${triggerKey} in ${JSON.stringify(this.triggers)}`);
-            throw new error_1.FirebaseError(`No trigger with key ${triggerKey}`);
+            throw new error_1.FirebaseError(`No function with key ${triggerKey}`);
         }
         return record;
     }
@@ -475,30 +484,12 @@ class FunctionsEmulator {
     setTriggersForTesting(triggers, backend) {
         triggers.forEach((def) => this.addTriggerRecord(def, { backend, ignored: false }));
     }
-    getBaseBundle(backend) {
+    getBaseBundle() {
         return {
-            cwd: backend.functionsDir,
-            projectId: this.args.projectId,
-            triggerId: "",
-            targetName: "",
-            emulators: {
-                firestore: registry_1.EmulatorRegistry.getInfo(types_1.Emulators.FIRESTORE),
-                database: registry_1.EmulatorRegistry.getInfo(types_1.Emulators.DATABASE),
-                pubsub: registry_1.EmulatorRegistry.getInfo(types_1.Emulators.PUBSUB),
-                auth: registry_1.EmulatorRegistry.getInfo(types_1.Emulators.AUTH),
-                storage: registry_1.EmulatorRegistry.getInfo(types_1.Emulators.STORAGE),
-            },
-            adminSdkConfig: {
-                databaseURL: this.adminSdkConfig.databaseURL,
-                storageBucket: this.adminSdkConfig.storageBucket,
-            },
+            proto: {},
             disabled_features: this.args.disabledRuntimeFeatures,
         };
     }
-    getRequestedNodeRuntimeVersion(frb) {
-        const pkg = require(path.join(frb.cwd, "package.json"));
-        return frb.nodeMajorVersion || (pkg.engines && pkg.engines.node);
-    }
     getNodeBinary(backend) {
         const pkg = require(path.join(backend.functionsDir, "package.json"));
         if ((!pkg.engines || !pkg.engines.node) && !backend.nodeMajorVersion) {
@@ -546,16 +537,16 @@ class FunctionsEmulator {
         }
         return {};
     }
-    getSystemEnvs(triggerDef) {
+    getSystemEnvs(trigger) {
         const envs = {};
         envs.GCLOUD_PROJECT = this.args.projectId;
         envs.K_REVISION = "1";
         envs.PORT = "80";
-        if (triggerDef) {
-            const service = triggerDef.targetName;
+        if (trigger) {
+            const service = trigger.name;
             const target = service.replace(/-/g, ".");
             envs.FUNCTION_TARGET = target;
-            envs.FUNCTION_SIGNATURE_TYPE = triggerDef.signatureType;
+            envs.FUNCTION_SIGNATURE_TYPE = (0, functionsEmulatorShared_1.getSignatureType)(trigger);
             envs.K_SERVICE = service;
         }
         return envs;
@@ -607,12 +598,50 @@ class FunctionsEmulator {
             projectId: this.args.projectId,
         });
     }
-    getRuntimeEnvs(backend, triggerDef) {
-        return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, this.getUserEnvs(backend)), this.getSystemEnvs(triggerDef)), this.getEmulatorEnvs()), { FIREBASE_CONFIG: this.getFirebaseConfig() }), backend.env);
+    getRuntimeEnvs(backend, trigger) {
+        return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, this.getUserEnvs(backend)), this.getSystemEnvs(trigger)), this.getEmulatorEnvs()), { FIREBASE_CONFIG: this.getFirebaseConfig() }), backend.env);
     }
-    invokeRuntime(frb, opts, runtimeEnv) {
-        if (this.workerPool.readyForWork(frb.triggerId)) {
-            return this.workerPool.submitWork(frb.triggerId, frb, opts);
+    async resolveSecretEnvs(backend, trigger) {
+        let secretEnvs = {};
+        try {
+            const data = fs.readFileSync(path.join(backend.functionsDir, LOCAL_SECRETS_FILE), "utf8");
+            secretEnvs = functionsEnv.parseStrict(data);
+        }
+        catch (e) {
+            if (e.code !== "ENOENT") {
+                this.logger.logLabeled("ERROR", "functions", `Failed to read local secrets file ${LOCAL_SECRETS_FILE}: ${e.message}`);
+            }
+        }
+        const secrets = trigger.secretEnvironmentVariables || [];
+        const accesses = secrets
+            .filter((s) => !secretEnvs[s.secret])
+            .map(async (s) => {
+            this.logger.logLabeled("INFO", "functions", `Trying to access secret ${s.key}@latest`);
+            const value = await (0, secretManager_1.accessSecretVersion)(this.getProjectId(), s.key, "latest");
+            return [s.secret, value];
+        });
+        const accessResults = await (0, utils_1.allSettled)(accesses);
+        const errs = [];
+        for (const result of accessResults) {
+            if (result.status === "rejected") {
+                errs.push(result.reason);
+            }
+            else {
+                const [k, v] = result.value;
+                secretEnvs[k] = v;
+            }
+        }
+        if (errs.length > 0) {
+            this.logger.logLabeled("ERROR", "functions", "Unable to access secret environment variables from Google Cloud Secret Manager. " +
+                "Make sure the credential used for the Functions Emulator have access " +
+                `or provide override values in ${LOCAL_SECRETS_FILE}:\n\t` +
+                errs.join("\n\t"));
+        }
+        return secretEnvs;
+    }
+    async invokeRuntime(backend, trigger, frb, opts) {
+        if (this.workerPool.readyForWork(trigger.id)) {
+            return this.workerPool.submitWork(trigger.id, frb, opts);
         }
         const emitter = new events_1.EventEmitter();
         const args = [path.join(__dirname, "functionsEmulatorRuntime")];
@@ -621,7 +650,7 @@ class FunctionsEmulator {
         }
         if (this.args.debugPort) {
             if (process.env.FIREPIT_VERSION && process.execPath == opts.nodeBinary) {
-                const requestedMajorNodeVersion = this.getRequestedNodeRuntimeVersion(frb);
+                const requestedMajorNodeVersion = this.getNodeBinary(backend);
                 this.logger.log("WARN", `To enable function inspection, please run "${process.execPath} is:npm i node@${requestedMajorNodeVersion} --save-dev" in your functions directory`);
             }
             else {
@@ -629,15 +658,17 @@ class FunctionsEmulator {
                 args.unshift(`--inspect=${host}:${this.args.debugPort}`);
             }
         }
-        const pnpPath = path.join(frb.cwd, ".pnp.js");
+        const pnpPath = path.join(backend.functionsDir, ".pnp.js");
         if (fs.existsSync(pnpPath)) {
             emulatorLogger_1.EmulatorLogger.forEmulator(types_1.Emulators.FUNCTIONS).logLabeled("WARN_ONCE", "functions", "Detected yarn@2 with PnP. " +
                 "Cloud Functions for Firebase requires a node_modules folder to work correctly and is therefore incompatible with PnP. " +
                 "See https://yarnpkg.com/getting-started/migration#step-by-step for more information.");
         }
+        const runtimeEnv = this.getRuntimeEnvs(backend, trigger);
+        const secretEnvs = await this.resolveSecretEnvs(backend, trigger);
         const childProcess = spawn(opts.nodeBinary, args, {
-            env: Object.assign(Object.assign({ node: opts.nodeBinary }, process.env), (runtimeEnv !== null && runtimeEnv !== void 0 ? runtimeEnv : {})),
-            cwd: frb.cwd,
+            cwd: backend.functionsDir,
+            env: Object.assign(Object.assign(Object.assign({ node: opts.nodeBinary }, process.env), runtimeEnv), secretEnvs),
             stdio: ["pipe", "pipe", "pipe", "ipc"],
         });
         if (!childProcess.stderr) {
@@ -668,6 +699,7 @@ class FunctionsEmulator {
                 childProcess.on("exit", resolve);
             }),
             events: emitter,
+            cwd: backend.functionsDir,
             shutdown: () => {
                 childProcess.kill();
             },
@@ -679,8 +711,8 @@ class FunctionsEmulator {
                 return childProcess.send(JSON.stringify(args));
             },
         };
-        this.workerPool.addWorker(frb.triggerId, runtime);
-        return this.workerPool.submitWork(frb.triggerId, frb, opts);
+        this.workerPool.addWorker(trigger.id, runtime);
+        return this.workerPool.submitWork(trigger.id, frb, opts);
     }
     async disableBackgroundTriggers() {
         Object.values(this.triggers).forEach((record) => {
@@ -706,7 +738,7 @@ class FunctionsEmulator {
         }
         const trigger = record.def;
         const service = (0, functionsEmulatorShared_1.getFunctionService)(trigger);
-        const worker = this.startFunctionRuntime(record.backend, trigger.id, trigger.name, (0, functionsEmulatorShared_1.getSignatureType)(trigger), proto);
+        const worker = await this.startFunctionRuntime(record.backend, trigger, proto);
         return new Promise((resolve, reject) => {
             if (projectId !== this.args.projectId) {
                 if (service !== constants_1.Constants.SERVICE_REALTIME_DATABASE) {
@@ -740,7 +772,7 @@ class FunctionsEmulator {
         return registry_1.EmulatorRegistry.getInfo(emulator);
     }
     tokenFromAuthHeader(authHeader) {
-        const match = authHeader.match(/^Bearer (.*)$/);
+        const match = /^Bearer (.*)$/.exec(authHeader);
         if (!match) {
             return;
         }
@@ -772,7 +804,7 @@ class FunctionsEmulator {
         if (!this.triggers[triggerId]) {
             res
                 .status(404)
-                .send(`Function ${triggerId} does not exist, valid triggers are: ${Object.keys(this.triggers).join(", ")}`);
+                .send(`Function ${triggerId} does not exist, valid functions are: ${Object.keys(this.triggers).join(", ")}`);
             return;
         }
         const record = this.getTriggerRecordByKey(triggerId);
@@ -793,7 +825,7 @@ class FunctionsEmulator {
                 req.headers[functionsEmulatorShared_1.HttpConstants.CALLABLE_AUTH_HEADER] = encodeURIComponent(JSON.stringify(contextAuth));
             }
         }
-        const worker = this.startFunctionRuntime(record.backend, trigger.id, trigger.name, "http", undefined);
+        const worker = await this.startFunctionRuntime(record.backend, trigger);
         worker.onLogs((el) => {
             if (el.level === "FATAL") {
                 res.status(500).send(el.text);