firebase-tools 10.1.2 → 10.2.0

package/lib/deploy/hosting/convertConfig.js

@@ -1,11 +1,24 @@
 "use strict";
-const _ = require("lodash");
-const { FirebaseError } = require("../../error");
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertConfig = void 0;
+const error_1 = require("../../error");
+function has(obj, k) {
+    return obj[k] !== undefined;
+}
 function extractPattern(type, spec) {
-    const glob = spec.source || spec.glob;
-    const regex = spec.regex;
+    let glob = "";
+    let regex = "";
+    if ("source" in spec) {
+        glob = spec.source;
+    }
+    if ("glob" in spec) {
+        glob = spec.glob;
+    }
+    if ("regex" in spec) {
+        regex = spec.regex;
+    }
     if (glob && regex) {
-        throw new FirebaseError("Cannot specify a " + type + " pattern with both a glob and regex.");
+        throw new error_1.FirebaseError(`Cannot specify a ${type} pattern with both a glob and regex.`);
     }
     else if (glob) {
         return { glob: glob };
@@ -13,33 +26,38 @@ function extractPattern(type, spec) {
     else if (regex) {
         return { regex: regex };
     }
-    throw new FirebaseError("Cannot specify a " + type + " with no pattern (either a glob or regex required).");
+    throw new error_1.FirebaseError(`Cannot specify a ${type} with no pattern (either a glob or regex required).`);
 }
-module.exports = function (config) {
+function convertConfig(config) {
+    if (Array.isArray(config)) {
+        throw new error_1.FirebaseError(`convertConfig should be given a single configuration, not an array.`, {
+            exit: 2,
+        });
+    }
     const out = {};
     if (!config) {
         return out;
     }
-    if (_.isArray(config.rewrites)) {
-        out.rewrites = config.rewrites.map(function (rewrite) {
+    if (Array.isArray(config.rewrites)) {
+        out.rewrites = config.rewrites.map((rewrite) => {
             const vRewrite = extractPattern("rewrite", rewrite);
-            if (rewrite.destination) {
+            if ("destination" in rewrite) {
                 vRewrite.path = rewrite.destination;
             }
-            else if (rewrite.function) {
+            else if ("function" in rewrite) {
                 vRewrite.function = rewrite.function;
             }
-            else if (rewrite.dynamicLinks) {
+            else if ("dynamicLinks" in rewrite) {
                 vRewrite.dynamicLinks = rewrite.dynamicLinks;
             }
-            else if (rewrite.run) {
+            else if ("run" in rewrite) {
                 vRewrite.run = Object.assign({ region: "us-central1" }, rewrite.run);
             }
             return vRewrite;
         });
     }
-    if (_.isArray(config.redirects)) {
-        out.redirects = config.redirects.map(function (redirect) {
+    if (Array.isArray(config.redirects)) {
+        out.redirects = config.redirects.map((redirect) => {
             const vRedirect = extractPattern("redirect", redirect);
             vRedirect.location = redirect.destination;
             if (redirect.type) {
@@ -48,17 +66,19 @@ module.exports = function (config) {
             return vRedirect;
         });
     }
-    if (_.isArray(config.headers)) {
-        out.headers = config.headers.map(function (header) {
+    if (Array.isArray(config.headers)) {
+        out.headers = config.headers.map((header) => {
             const vHeader = extractPattern("header", header);
             vHeader.headers = {};
-            (header.headers || []).forEach(function (h) {
-                vHeader.headers[h.key] = h.value;
-            });
+            if (Array.isArray(header.headers) && header.headers.length) {
+                header.headers.forEach((h) => {
+                    vHeader.headers[h.key] = h.value;
+                });
+            }
             return vHeader;
         });
     }
-    if (_.has(config, "cleanUrls")) {
+    if (has(config, "cleanUrls")) {
         out.cleanUrls = config.cleanUrls;
     }
     if (config.trailingSlash === true) {
@@ -67,11 +87,12 @@ module.exports = function (config) {
     else if (config.trailingSlash === false) {
         out.trailingSlashBehavior = "REMOVE";
     }
-    if (_.has(config, "appAssociation")) {
+    if (has(config, "appAssociation")) {
         out.appAssociation = config.appAssociation;
     }
-    if (_.has(config, "i18n")) {
+    if (has(config, "i18n")) {
         out.i18n = config.i18n;
     }
     return out;
-};
+}
+exports.convertConfig = convertConfig;

package/lib/deploy/hosting/prepare.js

@@ -1,7 +1,7 @@
 "use strict";
 const _ = require("lodash");
 const api = require("../../api");
-const convertConfig = require("./convertConfig");
+const { convertConfig } = require("./convertConfig");
 const deploymentTool = require("../../deploymentTool");
 const { FirebaseError } = require("../../error");
 const { normalizedHostingConfigs } = require("../../hosting/normalizedHostingConfigs");

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) {
@@ -525,7 +516,9 @@ class FunctionsEmulator {
         if (requestedMajorVersion === hostMajorVersion) {
             this.logger.logLabeled("SUCCESS", "functions", `Using node@${requestedMajorVersion} from host.`);
         }
-        this.logger.log("WARN", `Your requested "node" version "${requestedMajorVersion}" doesn't match your global version "${hostMajorVersion}"`);
+        else {
+            this.logger.log("WARN", `Your requested "node" version "${requestedMajorVersion}" doesn't match your global version "${hostMajorVersion}". Using node@${hostMajorVersion} from host.`);
+        }
         return process.execPath;
     }
     getUserEnvs(backend) {
@@ -544,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;
@@ -605,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);
+    }
+    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;
     }
-    invokeRuntime(frb, opts, runtimeEnv) {
-        if (this.workerPool.readyForWork(frb.triggerId)) {
-            return this.workerPool.submitWork(frb.triggerId, frb, opts);
+    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")];
@@ -619,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 {
@@ -627,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) {
@@ -666,6 +699,7 @@ class FunctionsEmulator {
                 childProcess.on("exit", resolve);
             }),
             events: emitter,
+            cwd: backend.functionsDir,
             shutdown: () => {
                 childProcess.kill();
             },
@@ -677,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) => {
@@ -704,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) {
@@ -738,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;
         }
@@ -770,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);
@@ -791,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);