firebase-tools 10.2.2 → 10.4.0

package/lib/emulator/storage/upload.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UploadService = exports.NotCancellableError = exports.UploadNotActiveError = exports.UploadStatus = exports.UploadType = void 0;
+const uuid_1 = require("uuid");
+const errors_1 = require("./errors");
+var UploadType;
+(function (UploadType) {
+    UploadType[UploadType["MULTIPART"] = 0] = "MULTIPART";
+    UploadType[UploadType["RESUMABLE"] = 1] = "RESUMABLE";
+})(UploadType = exports.UploadType || (exports.UploadType = {}));
+var UploadStatus;
+(function (UploadStatus) {
+    UploadStatus[UploadStatus["ACTIVE"] = 0] = "ACTIVE";
+    UploadStatus[UploadStatus["CANCELLED"] = 1] = "CANCELLED";
+    UploadStatus[UploadStatus["FINISHED"] = 2] = "FINISHED";
+})(UploadStatus = exports.UploadStatus || (exports.UploadStatus = {}));
+class UploadNotActiveError extends Error {
+}
+exports.UploadNotActiveError = UploadNotActiveError;
+class NotCancellableError extends Error {
+}
+exports.NotCancellableError = NotCancellableError;
+class UploadService {
+    constructor(_persistence) {
+        this._persistence = _persistence;
+        this.reset();
+    }
+    reset() {
+        this._uploads = new Map();
+    }
+    multipartUpload(request) {
+        const upload = this.startMultipartUpload(request, request.dataRaw.byteLength);
+        this._persistence.deleteFile(upload.path, true);
+        this._persistence.appendBytes(upload.path, request.dataRaw);
+        return upload;
+    }
+    startMultipartUpload(request, sizeInBytes) {
+        const id = (0, uuid_1.v4)();
+        const upload = {
+            id: (0, uuid_1.v4)(),
+            bucketId: request.bucketId,
+            objectId: request.objectId,
+            type: UploadType.MULTIPART,
+            path: this.getStagingFileName(id, request.bucketId, request.objectId),
+            status: UploadStatus.FINISHED,
+            metadata: JSON.parse(request.metadataRaw),
+            size: sizeInBytes,
+            authorization: request.authorization,
+        };
+        this._uploads.set(upload.id, upload);
+        return upload;
+    }
+    startResumableUpload(request) {
+        const id = (0, uuid_1.v4)();
+        const upload = {
+            id: id,
+            bucketId: request.bucketId,
+            objectId: request.objectId,
+            type: UploadType.RESUMABLE,
+            path: this.getStagingFileName(id, request.bucketId, request.objectId),
+            status: UploadStatus.ACTIVE,
+            metadata: JSON.parse(request.metadataRaw),
+            size: 0,
+            authorization: request.authorization,
+        };
+        this._uploads.set(upload.id, upload);
+        this._persistence.deleteFile(upload.path, true);
+        return upload;
+    }
+    continueResumableUpload(uploadId, dataRaw) {
+        const upload = this.getResumableUpload(uploadId);
+        if (upload.status !== UploadStatus.ACTIVE) {
+            throw new UploadNotActiveError();
+        }
+        this._persistence.appendBytes(upload.path, dataRaw);
+        upload.size += dataRaw.byteLength;
+        return upload;
+    }
+    getResumableUpload(uploadId) {
+        const upload = this._uploads.get(uploadId);
+        if (!upload || upload.type !== UploadType.RESUMABLE) {
+            throw new errors_1.NotFoundError();
+        }
+        return upload;
+    }
+    cancelResumableUpload(uploadId) {
+        const upload = this.getResumableUpload(uploadId);
+        if (upload.status === UploadStatus.FINISHED) {
+            throw new NotCancellableError();
+        }
+        upload.status = UploadStatus.CANCELLED;
+        return upload;
+    }
+    finalizeResumableUpload(uploadId) {
+        const upload = this.getResumableUpload(uploadId);
+        if (upload.status === UploadStatus.CANCELLED) {
+            throw new UploadNotActiveError();
+        }
+        upload.status = UploadStatus.FINISHED;
+        return upload;
+    }
+    getStagingFileName(uploadId, bucketId, objectId) {
+        return encodeURIComponent(`${uploadId}_b_${bucketId}_o_${objectId}`);
+    }
+}
+exports.UploadService = UploadService;

package/lib/extensions/askUserForParam.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ask = exports.getInquirerDefault = exports.promptCreateSecret = exports.askForParam = exports.checkResponse = void 0;
+exports.getInquirerDefault = exports.promptCreateSecret = exports.askForParam = exports.ask = exports.checkResponse = exports.SecretLocation = void 0;
 const _ = require("lodash");
 const clc = require("cli-color");
 const { marked } = require("marked");
@@ -12,10 +12,15 @@ const utils_1 = require("./utils");
 const logger_1 = require("../logger");
 const prompt_1 = require("../prompt");
 const utils = require("../utils");
+var SecretLocation;
+(function (SecretLocation) {
+    SecretLocation[SecretLocation["CLOUD"] = 1] = "CLOUD";
+    SecretLocation[SecretLocation["LOCAL"] = 2] = "LOCAL";
+})(SecretLocation = exports.SecretLocation || (exports.SecretLocation = {}));
 var SecretUpdateAction;
 (function (SecretUpdateAction) {
-    SecretUpdateAction[SecretUpdateAction["LEAVE"] = 0] = "LEAVE";
-    SecretUpdateAction[SecretUpdateAction["SET_NEW"] = 1] = "SET_NEW";
+    SecretUpdateAction[SecretUpdateAction["LEAVE"] = 1] = "LEAVE";
+    SecretUpdateAction[SecretUpdateAction["SET_NEW"] = 2] = "SET_NEW";
 })(SecretUpdateAction || (SecretUpdateAction = {}));
 function checkResponse(response, spec) {
     let valid = true;
@@ -55,9 +60,35 @@ function checkResponse(response, spec) {
     return valid;
 }
 exports.checkResponse = checkResponse;
-async function askForParam(projectId, instanceId, paramSpec, reconfiguring) {
+async function ask(projectId, instanceId, paramSpecs, firebaseProjectParams, reconfiguring) {
+    if (_.isEmpty(paramSpecs)) {
+        logger_1.logger.debug("No params were specified for this extension.");
+        return {};
+    }
+    utils.logLabeledBullet(extensionsHelper_1.logPrefix, "answer the questions below to configure your extension:");
+    const substituted = (0, extensionsHelper_1.substituteParams)(paramSpecs, firebaseProjectParams);
+    const result = {};
+    const promises = _.map(substituted, (paramSpec) => {
+        return async () => {
+            result[paramSpec.param] = await askForParam({
+                projectId,
+                instanceId,
+                paramSpec,
+                reconfiguring,
+            });
+        };
+    });
+    await promises.reduce((prev, cur) => prev.then(cur), Promise.resolve());
+    logger_1.logger.info();
+    return result;
+}
+exports.ask = ask;
+async function askForParam(args) {
+    const paramSpec = args.paramSpec;
     let valid = false;
     let response = "";
+    let responseForLocal;
+    let secretLocations = [];
     const description = paramSpec.description || "";
     const label = paramSpec.label.trim();
     logger_1.logger.info(`\n${clc.bold(label)}${clc.bold(paramSpec.required ? "" : " (Optional)")}: ${marked(description).trim()}`);
@@ -92,16 +123,23 @@ async function askForParam(projectId, instanceId, paramSpec, reconfiguring) {
                         }
                     },
                     message: "Which options do you want enabled for this parameter? " +
-                        "Press Space to select, then Enter to confirm your choices. " +
-                        "You may select multiple options.",
+                        "Press Space to select, then Enter to confirm your choices. ",
                     choices: (0, utils_1.convertExtensionOptionToLabeledList)(paramSpec.options),
                 });
                 valid = checkResponse(response, paramSpec);
                 break;
             case extensionsApi_1.ParamType.SECRET:
-                response = reconfiguring
-                    ? await promptReconfigureSecret(projectId, instanceId, paramSpec)
-                    : await promptCreateSecret(projectId, instanceId, paramSpec);
+                while (!secretLocations.length) {
+                    secretLocations = await promptSecretLocations();
+                }
+                if (secretLocations.includes(SecretLocation.CLOUD.toString())) {
+                    response = args.reconfiguring
+                        ? await promptReconfigureSecret(args.projectId, args.instanceId, paramSpec)
+                        : await promptCreateSecret(args.projectId, args.instanceId, paramSpec);
+                }
+                if (secretLocations.includes(SecretLocation.LOCAL.toString())) {
+                    responseForLocal = await promptLocalSecret(args.instanceId, paramSpec);
+                }
                 valid = true;
                 break;
             default:
@@ -114,9 +152,38 @@ async function askForParam(projectId, instanceId, paramSpec, reconfiguring) {
                 valid = checkResponse(response, paramSpec);
         }
     }
-    return response;
+    return Object.assign({ baseValue: response }, (responseForLocal ? { local: responseForLocal } : {}));
 }
 exports.askForParam = askForParam;
+async function promptSecretLocations() {
+    return await (0, prompt_1.promptOnce)({
+        name: "input",
+        type: "checkbox",
+        message: "Where would you like to store your secrets? You must select at least one value",
+        choices: [
+            {
+                checked: true,
+                name: "Google Cloud Secret Manager",
+                value: SecretLocation.CLOUD.toString(),
+            },
+            {
+                checked: false,
+                name: "Local file (Only used by Firebase Emulator)",
+                value: SecretLocation.LOCAL.toString(),
+            },
+        ],
+    });
+}
+async function promptLocalSecret(instanceId, paramSpec) {
+    utils.logLabeledBullet(extensionsHelper_1.logPrefix, "Configure a local secret value for Extensions Emulator");
+    const value = await (0, prompt_1.promptOnce)({
+        name: paramSpec.param,
+        type: "input",
+        message: `This secret will be stored in ./extensions/${instanceId}.secret.local.\n` +
+            `Enter value for "${paramSpec.label.trim()}" to be used by Extensions Emulator:`,
+    });
+    return value;
+}
 async function promptReconfigureSecret(projectId, instanceId, paramSpec) {
     const action = await (0, prompt_1.promptOnce)({
         type: "list",
@@ -210,21 +277,3 @@ function getInquirerDefault(options, def) {
     return defaultOption ? defaultOption.label || defaultOption.value : "";
 }
 exports.getInquirerDefault = getInquirerDefault;
-async function ask(projectId, instanceId, paramSpecs, firebaseProjectParams, reconfiguring) {
-    if (_.isEmpty(paramSpecs)) {
-        logger_1.logger.debug("No params were specified for this extension.");
-        return {};
-    }
-    utils.logLabeledBullet(extensionsHelper_1.logPrefix, "answer the questions below to configure your extension:");
-    const substituted = (0, extensionsHelper_1.substituteParams)(paramSpecs, firebaseProjectParams);
-    const result = {};
-    const promises = _.map(substituted, (paramSpec) => {
-        return async () => {
-            result[paramSpec.param] = await askForParam(projectId, instanceId, paramSpec, reconfiguring);
-        };
-    });
-    await promises.reduce((prev, cur) => prev.then(cur), Promise.resolve());
-    logger_1.logger.info();
-    return result;
-}
-exports.ask = ask;

package/lib/extensions/emulator/optionsHelper.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getParams = exports.getExtensionFunctionInfo = exports.buildOptions = void 0;
+exports.getParams = exports.getSecretEnvVars = exports.getNonSecretEnv = exports.getExtensionFunctionInfo = exports.buildOptions = void 0;
 const fs = require("fs-extra");
 const _ = require("lodash");
 const path = require("path");
@@ -8,6 +8,7 @@ const paramHelper = require("../paramHelper");
 const specHelper = require("./specHelper");
 const localHelper = require("../localHelper");
 const triggerHelper = require("./triggerHelper");
+const extensionsApi_1 = require("../extensionsApi");
 const extensionsHelper = require("../extensionsHelper");
 const config_1 = require("../../config");
 const error_1 = require("../../error");
@@ -35,9 +36,9 @@ async function buildOptions(options) {
     return options;
 }
 exports.buildOptions = buildOptions;
-async function getExtensionFunctionInfo(extensionDir, instanceId, params) {
+async function getExtensionFunctionInfo(extensionDir, instanceId, paramValues) {
     const spec = await specHelper.readExtensionYaml(extensionDir);
-    const functionResources = specHelper.getFunctionResourcesWithParamSubstitution(spec, params);
+    const functionResources = specHelper.getFunctionResourcesWithParamSubstitution(spec, paramValues);
     const extensionTriggers = functionResources
         .map((r) => triggerHelper.functionResourceToEmulatedTriggerDefintion(r))
         .map((trigger) => {
@@ -45,12 +46,43 @@ async function getExtensionFunctionInfo(extensionDir, instanceId, params) {
         return trigger;
     });
     const nodeMajorVersion = specHelper.getNodeVersion(functionResources);
+    const nonSecretEnv = getNonSecretEnv(spec.params, paramValues);
+    const secretEnvVariables = getSecretEnvVars(spec.params, paramValues);
     return {
         extensionTriggers,
         nodeMajorVersion,
+        nonSecretEnv,
+        secretEnvVariables,
     };
 }
 exports.getExtensionFunctionInfo = getExtensionFunctionInfo;
+const isSecretParam = (p) => p.type === extensionsHelper.SpecParamType.SECRET || p.type === extensionsApi_1.ParamType.SECRET;
+function getNonSecretEnv(params, paramValues) {
+    const getNonSecretEnv = Object.assign({}, paramValues);
+    const secretParams = params.filter(isSecretParam);
+    for (const p of secretParams) {
+        delete getNonSecretEnv[p.param];
+    }
+    return getNonSecretEnv;
+}
+exports.getNonSecretEnv = getNonSecretEnv;
+function getSecretEnvVars(params, paramValues) {
+    const secretEnvVar = [];
+    const secretParams = params.filter(isSecretParam);
+    for (const s of secretParams) {
+        if (paramValues[s.param]) {
+            const [, projectId, , secret, , version] = paramValues[s.param].split("/");
+            secretEnvVar.push({
+                key: s.param,
+                secret,
+                projectId,
+                version,
+            });
+        }
+    }
+    return secretEnvVar;
+}
+exports.getSecretEnvVars = getSecretEnvVars;
 function getParams(options, extensionSpec) {
     const projectId = (0, projectUtils_1.needProjectId)(options);
     const userParams = paramHelper.readEnvFile(options.testParams);

package/lib/extensions/extensionsHelper.js

@@ -14,6 +14,7 @@ const api_1 = require("../api");
 const archiveDirectory_1 = require("../archiveDirectory");
 const utils_1 = require("./utils");
 const functionsConfig_1 = require("../functionsConfig");
+const adminSdkConfig_1 = require("../emulator/adminSdkConfig");
 const resolveSource_1 = require("./resolveSource");
 const error_1 = require("../error");
 const diagnose_1 = require("./diagnose");
@@ -29,6 +30,7 @@ const logger_1 = require("../logger");
 const utils_2 = require("../utils");
 const changelog_1 = require("./changelog");
 const getProjectNumber_1 = require("../getProjectNumber");
+const constants_1 = require("../emulator/constants");
 var SpecParamType;
 (function (SpecParamType) {
     SpecParamType["SELECT"] = "select";
@@ -76,21 +78,28 @@ function getDBInstanceFromURL(databaseUrl = "") {
     return "";
 }
 exports.getDBInstanceFromURL = getDBInstanceFromURL;
-async function getFirebaseProjectParams(projectId) {
-    const body = await (0, functionsConfig_1.getFirebaseConfig)({ project: projectId });
-    const projectNumber = await (0, getProjectNumber_1.getProjectNumber)({ projectId });
+async function getFirebaseProjectParams(projectId, emulatorMode = false) {
+    var _a, _b;
+    const body = emulatorMode
+        ? await (0, adminSdkConfig_1.getProjectAdminSdkConfigOrCached)(projectId)
+        : await (0, functionsConfig_1.getFirebaseConfig)({ project: projectId });
+    const projectNumber = emulatorMode && constants_1.Constants.isDemoProject(projectId)
+        ? constants_1.Constants.FAKE_PROJECT_NUMBER
+        : await (0, getProjectNumber_1.getProjectNumber)({ projectId });
+    const databaseURL = (_a = body === null || body === void 0 ? void 0 : body.databaseURL) !== null && _a !== void 0 ? _a : `https://${projectId}.firebaseio.com`;
+    const storageBucket = (_b = body === null || body === void 0 ? void 0 : body.storageBucket) !== null && _b !== void 0 ? _b : `${projectId}.appspot.com`;
     const FIREBASE_CONFIG = JSON.stringify({
-        projectId: body.projectId,
-        databaseURL: body.databaseURL,
-        storageBucket: body.storageBucket,
+        projectId,
+        databaseURL,
+        storageBucket,
     });
     return {
-        PROJECT_ID: body.projectId,
+        PROJECT_ID: projectId,
         PROJECT_NUMBER: projectNumber,
-        DATABASE_URL: body.databaseURL,
-        STORAGE_BUCKET: body.storageBucket,
+        DATABASE_URL: databaseURL,
+        STORAGE_BUCKET: storageBucket,
         FIREBASE_CONFIG,
-        DATABASE_INSTANCE: getDBInstanceFromURL(body.databaseURL),
+        DATABASE_INSTANCE: getDBInstanceFromURL(databaseURL),
     };
 }
 exports.getFirebaseProjectParams = getFirebaseProjectParams;

package/lib/extensions/manifest.js

@@ -1,11 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeToManifest = void 0;
+exports.showPreviewWarning = exports.showDeprecationWarning = exports.readInstanceParam = exports.getInstanceRef = exports.instanceExists = exports.loadConfig = exports.removeFromManifest = exports.writeLocalSecrets = exports.writeToManifest = exports.ENV_DIRECTORY = void 0;
 const clc = require("cli-color");
+const path = require("path");
 const refs = require("./refs");
+const config_1 = require("../config");
 const logger_1 = require("../logger");
 const prompt_1 = require("../prompt");
-async function writeToManifest(specs, config, options) {
+const paramHelper_1 = require("./paramHelper");
+const error_1 = require("../error");
+const utils = require("../utils");
+const extensionsHelper_1 = require("./extensionsHelper");
+const extensionsApi_1 = require("./extensionsApi");
+exports.ENV_DIRECTORY = "extensions";
+async function writeToManifest(specs, config, options, allowOverwrite = false) {
     if (config.has("extensions") &&
         Object.keys(config.get("extensions")).length &&
         !options.nonInteractive &&
@@ -13,36 +21,156 @@ async function writeToManifest(specs, config, options) {
         const currentExtensions = Object.entries(config.get("extensions"))
             .map((i) => `${i[0]}: ${i[1]}`)
             .join("\n\t");
-        const overwrite = await (0, prompt_1.promptOnce)({
-            type: "list",
-            message: `firebase.json already contains extensions:\n${currentExtensions}\nWould you like to overwrite or merge?`,
-            choices: [
-                { name: "Overwrite", value: true },
-                { name: "Merge", value: false },
-            ],
-        });
-        if (overwrite) {
-            config.set("extensions", {});
+        if (allowOverwrite) {
+            const overwrite = await (0, prompt_1.promptOnce)({
+                type: "list",
+                message: `firebase.json already contains extensions:\n${currentExtensions}\nWould you like to overwrite or merge?`,
+                choices: [
+                    { name: "Overwrite", value: true },
+                    { name: "Merge", value: false },
+                ],
+            });
+            if (overwrite) {
+                config.set("extensions", {});
+            }
         }
     }
     writeExtensionsToFirebaseJson(specs, config);
     await writeEnvFiles(specs, config, options.force);
+    await writeLocalSecrets(specs, config, options.force);
 }
 exports.writeToManifest = writeToManifest;
+async function writeLocalSecrets(specs, config, force) {
+    for (const spec of specs) {
+        if (!spec.paramSpecs) {
+            continue;
+        }
+        const writeBuffer = {};
+        const locallyOverridenSecretParams = spec.paramSpecs.filter((p) => p.type === extensionsApi_1.ParamType.SECRET && spec.params[p.param].local);
+        for (const paramSpec of locallyOverridenSecretParams) {
+            const key = paramSpec.param;
+            const localValue = spec.params[key].local;
+            writeBuffer[key] = localValue;
+        }
+        const content = Object.entries(writeBuffer)
+            .sort((a, b) => {
+            return a[0].localeCompare(b[0]);
+        })
+            .map((r) => `${r[0]}=${r[1]}`)
+            .join("\n");
+        if (content) {
+            await config.askWriteProjectFile(`extensions/${spec.instanceId}.secret.local`, content, force);
+        }
+    }
+}
+exports.writeLocalSecrets = writeLocalSecrets;
+function removeFromManifest(instanceId, config) {
+    if (!instanceExists(instanceId, config)) {
+        throw new error_1.FirebaseError(`Extension instance ${instanceId} not found in firebase.json.`);
+    }
+    const extensions = config.get("extensions", {});
+    extensions[instanceId] = undefined;
+    config.set("extensions", extensions);
+    config.writeProjectFile("firebase.json", config.src);
+    logger_1.logger.info(`Removed extension instance ${instanceId} from firebase.json`);
+    config.deleteProjectFile(`extensions/${instanceId}.env`);
+    logger_1.logger.info(`Removed extension instance environment config extensions/${instanceId}.env`);
+    if (config.projectFileExists(`extensions/${instanceId}.env.local`)) {
+        config.deleteProjectFile(`extensions/${instanceId}.env.local`);
+        logger_1.logger.info(`Removed extension instance local environment config extensions/${instanceId}.env.local`);
+    }
+    if (config.projectFileExists(`extensions/${instanceId}.secret.local`)) {
+        config.deleteProjectFile(`extensions/${instanceId}.secret.local`);
+        logger_1.logger.info(`Removed extension instance local secret config extensions/${instanceId}.secret.local`);
+    }
+}
+exports.removeFromManifest = removeFromManifest;
+function loadConfig(options) {
+    const existingConfig = config_1.Config.load(options, true);
+    if (!existingConfig) {
+        throw new error_1.FirebaseError("Not currently in a Firebase directory. Run `firebase init` to create a Firebase directory.");
+    }
+    return existingConfig;
+}
+exports.loadConfig = loadConfig;
+function instanceExists(instanceId, config) {
+    return !!config.get("extensions", {})[instanceId];
+}
+exports.instanceExists = instanceExists;
+function getInstanceRef(instanceId, config) {
+    if (!instanceExists(instanceId, config)) {
+        throw new error_1.FirebaseError(`Could not find extension instance ${instanceId} in firebase.json`);
+    }
+    const ref = config.get("extensions", {})[instanceId];
+    return refs.parse(ref);
+}
+exports.getInstanceRef = getInstanceRef;
 function writeExtensionsToFirebaseJson(specs, config) {
     const extensions = config.get("extensions", {});
     for (const s of specs) {
         extensions[s.instanceId] = refs.toExtensionVersionRef(s.ref);
     }
     config.set("extensions", extensions);
-    logger_1.logger.info("Adding Extensions to " + clc.bold("firebase.json") + "...");
     config.writeProjectFile("firebase.json", config.src);
+    utils.logSuccess("Wrote extensions to " + clc.bold("firebase.json") + "...");
 }
 async function writeEnvFiles(specs, config, force) {
     for (const spec of specs) {
         const content = Object.entries(spec.params)
-            .map((r) => `${r[0]}=${r[1]}`)
+            .sort((a, b) => {
+            return a[0].localeCompare(b[0]);
+        })
+            .map((r) => `${r[0]}=${r[1].baseValue}`)
             .join("\n");
         await config.askWriteProjectFile(`extensions/${spec.instanceId}.env`, content, force);
     }
 }
+function readInstanceParam(args) {
+    var _a;
+    const aliases = (_a = args.aliases) !== null && _a !== void 0 ? _a : [];
+    const filesToCheck = [
+        `${args.instanceId}.env`,
+        ...aliases.map((alias) => `${args.instanceId}.env.${alias}`),
+        ...(args.projectNumber ? [`${args.instanceId}.env.${args.projectNumber}`] : []),
+        ...(args.projectId ? [`${args.instanceId}.env.${args.projectId}`] : []),
+    ];
+    if (args.checkLocal) {
+        filesToCheck.push(`${args.instanceId}.env.local`);
+    }
+    let noFilesFound = true;
+    const combinedParams = {};
+    for (const fileToCheck of filesToCheck) {
+        try {
+            const params = readParamsFile(args.projectDir, fileToCheck);
+            logger_1.logger.debug(`Successfully read params from ${fileToCheck}`);
+            noFilesFound = false;
+            Object.assign(combinedParams, params);
+        }
+        catch (err) {
+            logger_1.logger.debug(`${err}`);
+        }
+    }
+    if (noFilesFound) {
+        throw new error_1.FirebaseError(`No params file found for ${args.instanceId}`);
+    }
+    return combinedParams;
+}
+exports.readInstanceParam = readInstanceParam;
+function readParamsFile(projectDir, fileName) {
+    const paramPath = path.join(projectDir, exports.ENV_DIRECTORY, fileName);
+    const params = (0, paramHelper_1.readEnvFile)(paramPath);
+    return params;
+}
+function showDeprecationWarning() {
+    utils.logLabeledWarning(extensionsHelper_1.logPrefix, "The behavior of ext:install, ext:update, ext:configure, and ext:uninstall will change in firebase-tools@11.0.0. " +
+        "Instead of deploying extensions directly, " +
+        "changes to extension instances will be written to firebase.json and ./extensions/*.env. " +
+        `Then ${clc.bold("firebase deploy (--only extensions)")} will deploy the changes to your Firebase project. ` +
+        `To access this behavior now, pass the ${clc.bold("--local")} flag.`);
+}
+exports.showDeprecationWarning = showDeprecationWarning;
+function showPreviewWarning() {
+    utils.logLabeledWarning(extensionsHelper_1.logPrefix, "These changes will be reflected in your Firebase Emulator after restart. " +
+        `Run ${clc.bold("firebase deploy (--only extensions)")} to deploy the changes to your Firebase project. `);
+}
+exports.showPreviewWarning = showPreviewWarning;

package/lib/extensions/paramHelper.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.readEnvFile = exports.getParamsFromFile = exports.promptForNewParams = exports.getParamsForUpdate = exports.getParams = exports.getParamsWithCurrentValuesAsDefaults = void 0;
+exports.readEnvFile = exports.promptForNewParams = exports.getParamsForUpdate = exports.getParams = exports.getParamsWithCurrentValuesAsDefaults = exports.setNewDefaults = exports.buildBindingOptionsWithBaseValue = exports.getBaseParamBindings = void 0;
 const _ = require("lodash");
 const path = require("path");
 const clc = require("cli-color");
@@ -11,6 +11,22 @@ const extensionsHelper_1 = require("./extensionsHelper");
 const askUserForParam = require("./askUserForParam");
 const track = require("../track");
 const env = require("../functions/env");
+function getBaseParamBindings(params) {
+    let ret = {};
+    for (const [k, v] of Object.entries(params)) {
+        ret = Object.assign(Object.assign({}, ret), { [k]: v.baseValue });
+    }
+    return ret;
+}
+exports.getBaseParamBindings = getBaseParamBindings;
+function buildBindingOptionsWithBaseValue(baseParams) {
+    let paramOptions = {};
+    for (const [k, v] of Object.entries(baseParams)) {
+        paramOptions = Object.assign(Object.assign({}, paramOptions), { [k]: { baseValue: v } });
+    }
+    return paramOptions;
+}
+exports.buildBindingOptionsWithBaseValue = buildBindingOptionsWithBaseValue;
 function setNewDefaults(params, newDefaults) {
     params.forEach((param) => {
         if (newDefaults[param.param.toUpperCase()]) {
@@ -19,6 +35,7 @@ function setNewDefaults(params, newDefaults) {
     });
     return params;
 }
+exports.setNewDefaults = setNewDefaults;
 function getParamsWithCurrentValuesAsDefaults(extensionInstance) {
     const specParams = _.cloneDeep(_.get(extensionInstance, "config.source.spec.params", []));
     const currentParams = _.cloneDeep(_.get(extensionInstance, "config.params", {}));
@@ -87,29 +104,36 @@ async function getParamsForUpdate(args) {
 }
 exports.getParamsForUpdate = getParamsForUpdate;
 async function promptForNewParams(args) {
+    const newParamBindingOptions = buildBindingOptionsWithBaseValue(args.currentParams);
     const firebaseProjectParams = await (0, extensionsHelper_1.getFirebaseProjectParams)(args.projectId);
     const comparer = (param1, param2) => {
         return param1.type === param2.type && param1.param === param2.param;
     };
-    let paramsDiffDeletions = _.differenceWith(args.spec.params, _.get(args.newSpec, "params", []), comparer);
+    const oldParams = args.spec.params.filter((p) => Object.keys(args.currentParams).includes(p.param));
+    let paramsDiffDeletions = _.differenceWith(oldParams, args.newSpec.params, comparer);
     paramsDiffDeletions = (0, extensionsHelper_1.substituteParams)(paramsDiffDeletions, firebaseProjectParams);
-    let paramsDiffAdditions = _.differenceWith(args.newSpec.params, _.get(args.spec, "params", []), comparer);
+    let paramsDiffAdditions = _.differenceWith(args.newSpec.params, oldParams, comparer);
     paramsDiffAdditions = (0, extensionsHelper_1.substituteParams)(paramsDiffAdditions, firebaseProjectParams);
     if (paramsDiffDeletions.length) {
         logger_1.logger.info("The following params will no longer be used:");
         paramsDiffDeletions.forEach((param) => {
             logger_1.logger.info(clc.red(`- ${param.param}: ${args.currentParams[param.param.toUpperCase()]}`));
-            delete args.currentParams[param.param.toUpperCase()];
+            delete newParamBindingOptions[param.param.toUpperCase()];
         });
     }
     if (paramsDiffAdditions.length) {
         logger_1.logger.info("To update this instance, configure the following new parameters:");
         for (const param of paramsDiffAdditions) {
-            const chosenValue = await askUserForParam.askForParam(args.projectId, args.instanceId, param, false);
-            args.currentParams[param.param] = chosenValue;
+            const chosenValue = await askUserForParam.askForParam({
+                projectId: args.projectId,
+                instanceId: args.instanceId,
+                paramSpec: param,
+                reconfiguring: false,
+            });
+            newParamBindingOptions[param.param] = chosenValue;
         }
     }
-    return args.currentParams;
+    return newParamBindingOptions;
 }
 exports.promptForNewParams = promptForNewParams;
 function getParamsFromFile(args) {
@@ -125,9 +149,8 @@ function getParamsFromFile(args) {
     const params = (0, extensionsHelper_1.populateDefaultParams)(envParams, args.paramSpecs);
     (0, extensionsHelper_1.validateCommandLineParams)(params, args.paramSpecs);
     logger_1.logger.info(`Using param values from ${args.paramsEnvPath}`);
-    return params;
+    return buildBindingOptionsWithBaseValue(params);
 }
-exports.getParamsFromFile = getParamsFromFile;
 function readEnvFile(envPath) {
     const buf = fs.readFileSync(path.resolve(envPath), "utf8");
     const result = env.parse(buf.toString().trim());