firebase-tools 9.16.6 → 9.20.0

package/lib/extensions/extensionsHelper.js

@@ -1,11 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.confirmInstallInstance = exports.getSourceOrigin = exports.isLocalOrURLPath = exports.isLocalPath = exports.isUrlPath = exports.instanceIdExists = exports.promptForRepeatInstance = exports.promptForOfficialExtension = exports.confirmExtensionVersion = exports.getExtensionSourceFromName = exports.createSourceFromLocation = exports.publishExtensionVersionFromLocalSource = exports.ensureExtensionsApiEnabled = exports.promptForValidInstanceId = exports.validateSpec = exports.validateCommandLineParams = exports.populateDefaultParams = exports.substituteParams = exports.getFirebaseProjectParams = exports.getDBInstanceFromURL = exports.resourceTypeToNiceName = exports.AUTOPOULATED_PARAM_PLACEHOLDERS = exports.EXTENSIONS_BUCKET_NAME = exports.URL_REGEX = exports.logPrefix = exports.SourceOrigin = exports.SpecParamType = void 0;
+exports.confirm = exports.getSourceOrigin = exports.isLocalOrURLPath = exports.isLocalPath = exports.isUrlPath = exports.instanceIdExists = exports.promptForRepeatInstance = exports.promptForOfficialExtension = exports.displayReleaseNotes = exports.getExtensionSourceFromName = exports.createSourceFromLocation = exports.publishExtensionVersionFromLocalSource = exports.ensureExtensionsApiEnabled = exports.promptForValidInstanceId = exports.validateSpec = exports.validateCommandLineParams = exports.populateDefaultParams = exports.substituteParams = exports.getFirebaseProjectParams = exports.getDBInstanceFromURL = exports.resourceTypeToNiceName = exports.AUTOPOULATED_PARAM_PLACEHOLDERS = exports.EXTENSIONS_BUCKET_NAME = exports.URL_REGEX = exports.logPrefix = exports.SourceOrigin = exports.SpecParamType = void 0;
 const _ = require("lodash");
 const clc = require("cli-color");
 const ora = require("ora");
 const semver = require("semver");
 const marked = require("marked");
+const TerminalRenderer = require("marked-terminal");
+marked.setOptions({
+    renderer: new TerminalRenderer(),
+});
 const api_1 = require("../api");
 const archiveDirectory_1 = require("../archiveDirectory");
 const utils_1 = require("./utils");
@@ -17,16 +21,19 @@ const ensureApiEnabled_1 = require("../ensureApiEnabled");
 const storage_1 = require("../gcp/storage");
 const projectUtils_1 = require("../projectUtils");
 const extensionsApi_1 = require("./extensionsApi");
+const refs = require("./refs");
 const localHelper_1 = require("./localHelper");
 const prompt_1 = require("../prompt");
 const logger_1 = require("../logger");
 const utils_2 = require("../utils");
+const changelog_1 = require("./changelog");
 var SpecParamType;
 (function (SpecParamType) {
     SpecParamType["SELECT"] = "select";
     SpecParamType["MULTISELECT"] = "multiSelect";
     SpecParamType["STRING"] = "string";
     SpecParamType["SELECTRESOURCE"] = "selectResource";
+    SpecParamType["SECRET"] = "secret";
 })(SpecParamType = exports.SpecParamType || (exports.SpecParamType = {}));
 var SourceOrigin;
 (function (SourceOrigin) {
@@ -255,41 +262,60 @@ async function archiveAndUploadSource(extPath, bucketName) {
     const res = await storage_1.uploadObject(zippedSource, bucketName);
     return `/${res.bucket}/${res.object}`;
 }
-async function publishExtensionVersionFromLocalSource(publisherId, extensionId, rootDirectory) {
-    const extensionSpec = await localHelper_1.getLocalExtensionSpec(rootDirectory);
-    if (extensionSpec.name != extensionId) {
-        throw new error_1.FirebaseError(`Extension ID '${clc.bold(extensionId)}' does not match the name in extension.yaml '${clc.bold(extensionSpec.name)}'.`);
+async function publishExtensionVersionFromLocalSource(args) {
+    const extensionSpec = await localHelper_1.getLocalExtensionSpec(args.rootDirectory);
+    if (extensionSpec.name != args.extensionId) {
+        throw new error_1.FirebaseError(`Extension ID '${clc.bold(args.extensionId)}' does not match the name in extension.yaml '${clc.bold(extensionSpec.name)}'.`);
     }
     const subbedSpec = JSON.parse(JSON.stringify(extensionSpec));
     subbedSpec.params = substituteParams(extensionSpec.params || [], exports.AUTOPOULATED_PARAM_PLACEHOLDERS);
     validateSpec(subbedSpec);
-    const consent = await confirmExtensionVersion(publisherId, extensionId, extensionSpec.version);
-    if (!consent) {
-        return;
-    }
     let extension;
     try {
-        extension = await extensionsApi_1.getExtension(`${publisherId}/${extensionId}`);
+        extension = await extensionsApi_1.getExtension(`${args.publisherId}/${args.extensionId}`);
     }
     catch (err) {
     }
+    let notes;
+    try {
+        const changes = changelog_1.getLocalChangelog(args.rootDirectory);
+        notes = changes[extensionSpec.version];
+    }
+    catch (err) {
+        throw new error_1.FirebaseError("No CHANGELOG.md file found. " +
+            "Please create one and add an entry for this version. " +
+            marked("See https://firebase.google.com/docs/extensions/alpha/create-user-docs#writing-changelog for more details."));
+    }
+    if (!notes && extension) {
+        throw new error_1.FirebaseError(`No entry for version ${extensionSpec.version} found in CHANGELOG.md. ` +
+            "Please add one so users know what has changed in this version. " +
+            marked("See https://firebase.google.com/docs/extensions/alpha/create-user-docs#writing-changelog for more details."));
+    }
+    displayReleaseNotes(args.publisherId, args.extensionId, extensionSpec.version, notes);
+    if (!(await confirm({
+        nonInteractive: args.nonInteractive,
+        force: args.force,
+        default: false,
+    }))) {
+        return;
+    }
     if (extension &&
         extension.latestVersion &&
         semver.lt(extensionSpec.version, extension.latestVersion)) {
-        throw new error_1.FirebaseError(`The version you are trying to publish (${clc.bold(extensionSpec.version)}) is lower than the current version (${clc.bold(extension.latestVersion)}) for the extension '${clc.bold(`${publisherId}/${extensionId}`)}'. Please make sure this version is greater than the current version (${clc.bold(extension.latestVersion)}) inside of extension.yaml.\n`);
+        throw new error_1.FirebaseError(`The version you are trying to publish (${clc.bold(extensionSpec.version)}) is lower than the current version (${clc.bold(extension.latestVersion)}) for the extension '${clc.bold(`${args.publisherId}/${args.extensionId}`)}'. Please make sure this version is greater than the current version (${clc.bold(extension.latestVersion)}) inside of extension.yaml.\n`);
     }
     else if (extension &&
         extension.latestVersion &&
         semver.eq(extensionSpec.version, extension.latestVersion)) {
-        throw new error_1.FirebaseError(`The version you are trying to publish (${clc.bold(extensionSpec.version)}) already exists for the extension '${clc.bold(`${publisherId}/${extensionId}`)}'. Please increment the version inside of extension.yaml.\n`);
+        throw new error_1.FirebaseError(`The version you are trying to publish (${clc.bold(extensionSpec.version)}) already exists for the extension '${clc.bold(`${args.publisherId}/${args.extensionId}`)}'. Please increment the version inside of extension.yaml.\n`);
     }
-    const ref = `${publisherId}/${extensionId}@${extensionSpec.version}`;
+    const ref = `${args.publisherId}/${args.extensionId}@${extensionSpec.version}`;
     let packageUri;
     let objectPath = "";
     const uploadSpinner = ora.default(" Archiving and uploading extension source code");
     try {
         uploadSpinner.start();
-        objectPath = await archiveAndUploadSource(rootDirectory, exports.EXTENSIONS_BUCKET_NAME);
+        objectPath = await archiveAndUploadSource(args.rootDirectory, exports.EXTENSIONS_BUCKET_NAME);
         uploadSpinner.succeed(" Uploaded extension source code");
         packageUri = api_1.storageOrigin + objectPath + "?alt=media";
     }
@@ -307,7 +333,7 @@ async function publishExtensionVersionFromLocalSource(publisherId, extensionId,
     catch (err) {
         publishSpinner.fail();
         if (err.status == 404) {
-            throw new error_1.FirebaseError(marked(`Couldn't find publisher ID '${clc.bold(publisherId)}'. Please ensure that you have registered this ID. To register as a publisher, you can check out the [Firebase documentation](https://firebase.google.com/docs/extensions/alpha/share#register_as_an_extensions_publisher) for step-by-step instructions.`));
+            throw new error_1.FirebaseError(marked(`Couldn't find publisher ID '${clc.bold(args.publisherId)}'. Please ensure that you have registered this ID. To register as a publisher, you can check out the [Firebase documentation](https://firebase.google.com/docs/extensions/alpha/share#register_as_an_extensions_publisher) for step-by-step instructions.`));
         }
         throw err;
     }
@@ -369,17 +395,15 @@ async function getExtensionSourceFromName(extensionName) {
     throw new error_1.FirebaseError(`Could not find an extension named '${extensionName}'. `);
 }
 exports.getExtensionSourceFromName = getExtensionSourceFromName;
-async function confirmExtensionVersion(publisherId, extensionId, versionId) {
-    const message = `You are about to publish version ${clc.green(versionId)} of ${clc.green(`${publisherId}/${extensionId}`)} to Firebase's registry of extensions.\n\n` +
-        "Once an extension version is published, it cannot be changed. If you wish to make changes after publishing, you will need to publish a new version.\n\n" +
-        "Do you wish to continue?";
-    return await prompt_1.promptOnce({
-        type: "confirm",
-        message,
-        default: false,
-    });
+function displayReleaseNotes(publisherId, extensionId, versionId, releaseNotes) {
+    const releaseNotesMessage = releaseNotes
+        ? ` Release notes for this version:\n${marked(releaseNotes)}\n`
+        : "\n";
+    const message = `You are about to publish version ${clc.green(versionId)} of ${clc.green(`${publisherId}/${extensionId}`)} to Firebase's registry of extensions.${releaseNotesMessage}` +
+        "Once an extension version is published, it cannot be changed. If you wish to make changes after publishing, you will need to publish a new version.\n\n";
+    logger_1.logger.info(message);
 }
-exports.confirmExtensionVersion = confirmExtensionVersion;
+exports.displayReleaseNotes = displayReleaseNotes;
 async function promptForOfficialExtension(message) {
     const officialExts = await resolveSource_1.getExtensionRegistry(true);
     return await prompt_1.promptOnce({
@@ -392,11 +416,16 @@ async function promptForOfficialExtension(message) {
 }
 exports.promptForOfficialExtension = promptForOfficialExtension;
 async function promptForRepeatInstance(projectName, extensionName) {
-    const message = `An extension with the ID '${clc.bold(extensionName)}' already exists in the project '${clc.bold(projectName)}'.\n` +
-        `Do you want to proceed with installing another instance of extension '${clc.bold(extensionName)}' in this project?`;
+    const message = `An extension with the ID '${clc.bold(extensionName)}' already exists in the project '${clc.bold(projectName)}'. What would you like to do?`;
+    const choices = [
+        { name: "Update or reconfigure the existing instance", value: "updateExisting" },
+        { name: "Install a new instance with a different ID", value: "installNew" },
+        { name: "Cancel extension installation", value: "cancel" },
+    ];
     return await prompt_1.promptOnce({
-        type: "confirm",
+        type: "list",
         message,
+        choices,
     });
 }
 exports.promptForRepeatInstance = promptForRepeatInstance;
@@ -434,29 +463,17 @@ function isLocalOrURLPath(extInstallPath) {
     return isLocalPath(extInstallPath) || isUrlPath(extInstallPath);
 }
 exports.isLocalOrURLPath = isLocalOrURLPath;
-async function getSourceOrigin(sourceOrVersion) {
-    if (!sourceOrVersion) {
-        return SourceOrigin.OFFICIAL_EXTENSION;
-    }
-    if (semver.valid(sourceOrVersion)) {
-        return SourceOrigin.OFFICIAL_EXTENSION_VERSION;
-    }
+function getSourceOrigin(sourceOrVersion) {
     if (isLocalPath(sourceOrVersion)) {
         return SourceOrigin.LOCAL;
     }
     if (isUrlPath(sourceOrVersion)) {
         return SourceOrigin.URL;
     }
-    try {
-        await resolveSource_1.resolveRegistryEntry(sourceOrVersion);
-        return SourceOrigin.OFFICIAL_EXTENSION;
-    }
-    catch (_a) {
-    }
     if (sourceOrVersion.includes("/")) {
         let ref;
         try {
-            ref = extensionsApi_1.parseRef(sourceOrVersion);
+            ref = refs.parse(sourceOrVersion);
         }
         catch (err) {
         }
@@ -470,12 +487,20 @@ async function getSourceOrigin(sourceOrVersion) {
     throw new error_1.FirebaseError(`Could not find source '${clc.bold(sourceOrVersion)}'. Check to make sure the source is correct, and then please try again.`);
 }
 exports.getSourceOrigin = getSourceOrigin;
-async function confirmInstallInstance(defaultOption) {
-    const message = `Would you like to continue installing this extension?`;
-    return await prompt_1.promptOnce({
-        type: "confirm",
-        message,
-        default: defaultOption,
-    });
+async function confirm(args) {
+    if (!args.nonInteractive && !args.force) {
+        const message = `Do you wish to continue?`;
+        return await prompt_1.promptOnce({
+            type: "confirm",
+            message,
+            default: args.default,
+        });
+    }
+    else if (args.nonInteractive && !args.force) {
+        throw new error_1.FirebaseError("Pass the --force flag to use this command in non-interactive mode");
+    }
+    else {
+        return true;
+    }
 }
-exports.confirmInstallInstance = confirmInstallInstance;
+exports.confirm = confirm;

package/lib/extensions/paramHelper.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.readParamsFile = exports.promptForNewParams = exports.getParams = exports.getParamsWithCurrentValuesAsDefaults = void 0;
+exports.readEnvFile = exports.getParamsFromFile = exports.promptForNewParams = exports.getParamsForUpdate = exports.getParams = exports.getParamsWithCurrentValuesAsDefaults = void 0;
 const _ = require("lodash");
 const path = require("path");
 const clc = require("cli-color");
@@ -25,70 +25,113 @@ function getParamsWithCurrentValuesAsDefaults(extensionInstance) {
     return setNewDefaults(specParams, currentParams);
 }
 exports.getParamsWithCurrentValuesAsDefaults = getParamsWithCurrentValuesAsDefaults;
-async function getParams(projectId, paramSpecs, envFilePath) {
-    let commandLineParams;
-    if (envFilePath) {
-        try {
-            const buf = fs.readFileSync(path.resolve(envFilePath), "utf8");
-            commandLineParams = dotenv.parse(buf.toString().trim(), { debug: true });
-            track("Extension Env File", "Present");
-        }
-        catch (err) {
-            track("Extension Env File", "Invalid");
-            throw new error_1.FirebaseError(`Error reading env file: ${err.message}\n`, { original: err });
-        }
+async function getParams(args) {
+    let params;
+    if (args.nonInteractive && !args.paramsEnvPath) {
+        const paramsMessage = args.paramSpecs
+            .map((p) => {
+            return `\t${p.param}${p.required ? "" : " (Optional)"}`;
+        })
+            .join("\n");
+        throw new error_1.FirebaseError("In non-interactive mode but no `--params` flag found. " +
+            "To install this extension in non-interactive mode, set `--params` to a path to an .env file" +
+            " containing values for this extension's params:\n" +
+            paramsMessage);
+    }
+    else if (args.paramsEnvPath) {
+        params = getParamsFromFile({
+            projectId: args.projectId,
+            paramSpecs: args.paramSpecs,
+            noninteractive: args.nonInteractive,
+            paramsEnvPath: args.paramsEnvPath,
+        });
     }
     else {
-        track("Extension Env File", "Not Present");
+        const firebaseProjectParams = await extensionsHelper_1.getFirebaseProjectParams(args.projectId);
+        params = await askUserForParam.ask(args.projectId, args.instanceId, args.paramSpecs, firebaseProjectParams, !!args.reconfiguring);
     }
-    const firebaseProjectParams = await extensionsHelper_1.getFirebaseProjectParams(projectId);
+    track("Extension Params", _.isEmpty(params) ? "Not Present" : "Present", _.size(params));
+    return params;
+}
+exports.getParams = getParams;
+async function getParamsForUpdate(args) {
     let params;
-    if (commandLineParams) {
-        params = extensionsHelper_1.populateDefaultParams(commandLineParams, paramSpecs);
-        extensionsHelper_1.validateCommandLineParams(params, paramSpecs);
+    if (args.nonInteractive && !args.paramsEnvPath) {
+        const paramsMessage = args.newSpec.params
+            .map((p) => {
+            return `\t${p.param}${p.required ? "" : " (Optional)"}`;
+        })
+            .join("\n");
+        throw new error_1.FirebaseError("In non-interactive mode but no `--params` flag found. " +
+            "To update this extension in non-interactive mode, set `--params` to a path to an .env file" +
+            " containing values for this extension's params:\n" +
+            paramsMessage);
+    }
+    else if (args.paramsEnvPath) {
+        params = getParamsFromFile({
+            projectId: args.projectId,
+            paramSpecs: args.newSpec.params,
+            noninteractive: args.nonInteractive,
+            paramsEnvPath: args.paramsEnvPath,
+        });
     }
     else {
-        params = await askUserForParam.ask(paramSpecs, firebaseProjectParams);
+        params = await promptForNewParams({
+            spec: args.spec,
+            newSpec: args.newSpec,
+            currentParams: args.currentParams,
+            projectId: args.projectId,
+            instanceId: args.instanceId,
+        });
     }
     track("Extension Params", _.isEmpty(params) ? "Not Present" : "Present", _.size(params));
     return params;
 }
-exports.getParams = getParams;
-async function promptForNewParams(spec, newSpec, currentParams, projectId) {
-    const firebaseProjectParams = await extensionsHelper_1.getFirebaseProjectParams(projectId);
+exports.getParamsForUpdate = getParamsForUpdate;
+async function promptForNewParams(args) {
+    const firebaseProjectParams = await extensionsHelper_1.getFirebaseProjectParams(args.projectId);
     const comparer = (param1, param2) => {
         return param1.type === param2.type && param1.param === param2.param;
     };
-    let paramsDiffDeletions = _.differenceWith(spec.params, _.get(newSpec, "params", []), comparer);
+    let paramsDiffDeletions = _.differenceWith(args.spec.params, _.get(args.newSpec, "params", []), comparer);
     paramsDiffDeletions = extensionsHelper_1.substituteParams(paramsDiffDeletions, firebaseProjectParams);
-    let paramsDiffAdditions = _.differenceWith(newSpec.params, _.get(spec, "params", []), comparer);
+    let paramsDiffAdditions = _.differenceWith(args.newSpec.params, _.get(args.spec, "params", []), comparer);
     paramsDiffAdditions = 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}: ${currentParams[param.param.toUpperCase()]}`));
-            delete currentParams[param.param.toUpperCase()];
+            logger_1.logger.info(clc.red(`- ${param.param}: ${args.currentParams[param.param.toUpperCase()]}`));
+            delete args.currentParams[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(param);
-            currentParams[param.param] = chosenValue;
+            const chosenValue = await askUserForParam.askForParam(args.projectId, args.instanceId, param, false);
+            args.currentParams[param.param] = chosenValue;
         }
     }
-    return currentParams;
+    return args.currentParams;
 }
 exports.promptForNewParams = promptForNewParams;
-function readParamsFile(envFilePath) {
+function getParamsFromFile(args) {
+    let envParams;
     try {
-        const buf = fs.readFileSync(path.resolve(envFilePath), "utf8");
-        return dotenv.parse(buf.toString().trim(), { debug: true });
+        envParams = readEnvFile(args.paramsEnvPath);
+        track("Extension Env File", "Present");
     }
     catch (err) {
-        throw new error_1.FirebaseError(`Error reading --test-params file: ${err.message}\n`, {
-            original: err,
-        });
+        track("Extension Env File", "Invalid");
+        throw new error_1.FirebaseError(`Error reading env file: ${err.message}\n`, { original: err });
     }
+    const params = extensionsHelper_1.populateDefaultParams(envParams, args.paramSpecs);
+    extensionsHelper_1.validateCommandLineParams(params, args.paramSpecs);
+    logger_1.logger.info(`Using param values from ${args.paramsEnvPath}`);
+    return params;
+}
+exports.getParamsFromFile = getParamsFromFile;
+function readEnvFile(envPath) {
+    const buf = fs.readFileSync(path.resolve(envPath), "utf8");
+    return dotenv.parse(buf.toString().trim(), { debug: true });
 }
-exports.readParamsFile = readParamsFile;
+exports.readEnvFile = readEnvFile;

package/lib/extensions/refs.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toExtensionVersionName = exports.toExtensionName = exports.toExtensionVersionRef = exports.toExtensionRef = exports.parse = void 0;
+const semver = require("semver");
+const error_1 = require("../error");
+const refRegex = new RegExp(/^([^/@\n]+)\/{1}([^/@\n]+)(@{1}([^\n]+)|)$/);
+function parse(refOrName) {
+    const ret = parseRef(refOrName) || parseName(refOrName);
+    if (!ret || !ret.publisherId || !ret.extensionId) {
+        throw new error_1.FirebaseError(`Unable to parse ${refOrName} as an extension ref`);
+    }
+    if (ret.version &&
+        !semver.valid(ret.version) &&
+        !semver.validRange(ret.version) &&
+        ret.version !== "latest") {
+        throw new error_1.FirebaseError(`Extension reference ${ret} contains an invalid version ${ret.version}.`);
+    }
+    return ret;
+}
+exports.parse = parse;
+function parseRef(ref) {
+    const parts = refRegex.exec(ref);
+    if (parts && (parts.length == 5 || parts.length == 7)) {
+        const publisherId = parts[1];
+        const extensionId = parts[2];
+        const version = parts[4];
+        return { publisherId, extensionId, version };
+    }
+}
+function parseName(name) {
+    const parts = name.split("/");
+    return {
+        publisherId: parts[1],
+        extensionId: parts[3],
+        version: parts[5],
+    };
+}
+function toExtensionRef(ref) {
+    return `${ref.publisherId}/${ref.extensionId}`;
+}
+exports.toExtensionRef = toExtensionRef;
+function toExtensionVersionRef(ref) {
+    if (!ref.version) {
+        throw new error_1.FirebaseError(`Ref does not have a version`);
+    }
+    return `${ref.publisherId}/${ref.extensionId}@${ref.version}`;
+}
+exports.toExtensionVersionRef = toExtensionVersionRef;
+function toExtensionName(ref) {
+    return `publishers/${ref.publisherId}/extensions/${ref.extensionId}`;
+}
+exports.toExtensionName = toExtensionName;
+function toExtensionVersionName(ref) {
+    if (!ref.version) {
+        throw new error_1.FirebaseError(`Ref does not have a version`);
+    }
+    return `publishers/${ref.publisherId}/extensions/${ref.extensionId}/versions/${ref.version}`;
+}
+exports.toExtensionVersionName = toExtensionVersionName;

package/lib/extensions/resolveSource.js

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTrustedPublishers = exports.getExtensionRegistry = exports.promptForUpdateWarnings = exports.getMinRequiredVersion = exports.getTargetVersion = exports.resolveRegistryEntry = exports.isOfficialSource = exports.resolveSourceUrl = exports.confirmUpdateWarning = void 0;
+exports.getTrustedPublishers = exports.getExtensionRegistry = exports.getMinRequiredVersion = exports.getTargetVersion = exports.resolveRegistryEntry = exports.isOfficialSource = exports.resolveSourceUrl = exports.confirmUpdateWarning = void 0;
 const _ = require("lodash");
 const clc = require("cli-color");
 const marked = require("marked");
-const semver = require("semver");
 const api = require("../api");
 const error_1 = require("../error");
 const logger_1 = require("../logger");
@@ -58,23 +57,6 @@ function getMinRequiredVersion(registryEntry) {
     return _.get(registryEntry, ["labels", "minRequired"]);
 }
 exports.getMinRequiredVersion = getMinRequiredVersion;
-async function promptForUpdateWarnings(registryEntry, startVersion, endVersion) {
-    if (registryEntry.updateWarnings) {
-        for (const targetRange in registryEntry.updateWarnings) {
-            if (semver.satisfies(endVersion, targetRange)) {
-                const updateWarnings = registryEntry.updateWarnings[targetRange];
-                for (const updateWarning of updateWarnings) {
-                    if (semver.satisfies(startVersion, updateWarning.from)) {
-                        await module.exports.confirmUpdateWarning(updateWarning);
-                        break;
-                    }
-                }
-                break;
-            }
-        }
-    }
-}
-exports.promptForUpdateWarnings = promptForUpdateWarnings;
 async function getExtensionRegistry(onlyFeatured) {
     const res = await api.request("GET", EXTENSIONS_REGISTRY_ENDPOINT, {
         origin: api.firebaseExtensionsRegistryOrigin,
@@ -96,7 +78,7 @@ async function getTrustedPublishers() {
     }
     catch (err) {
         logger_1.logger.debug("Couldn't get extensions registry, assuming no trusted publishers except Firebase.");
-        return ["firebase "];
+        return ["firebase"];
     }
     const publisherIds = new Set();
     for (const entry in registry) {

package/lib/extensions/secretsUtils.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prettySecretName = exports.getSecretLabels = exports.getManagedSecrets = exports.grantFirexServiceAgentSecretAdminRole = exports.usesSecrets = exports.ensureSecretManagerApiEnabled = void 0;
+const getProjectNumber_1 = require("../getProjectNumber");
+const utils = require("../utils");
+const ensureApiEnabled_1 = require("../ensureApiEnabled");
+const projectUtils_1 = require("../projectUtils");
+const extensionsApi = require("./extensionsApi");
+const secretManagerApi = require("../gcp/secretManager");
+const logger_1 = require("../logger");
+const SECRET_LABEL = "firebase-extensions-managed";
+async function ensureSecretManagerApiEnabled(options) {
+    const projectId = projectUtils_1.needProjectId(options);
+    return await ensureApiEnabled_1.ensure(projectId, "secretmanager.googleapis.com", "extensions", options.markdown);
+}
+exports.ensureSecretManagerApiEnabled = ensureSecretManagerApiEnabled;
+function usesSecrets(spec) {
+    return spec.params && !!spec.params.find((p) => p.type == extensionsApi.ParamType.SECRET);
+}
+exports.usesSecrets = usesSecrets;
+async function grantFirexServiceAgentSecretAdminRole(secret) {
+    const projectNumber = await getProjectNumber_1.getProjectNumber({ projectId: secret.projectId });
+    const firexSaProjectId = utils.envOverride("FIREBASE_EXTENSIONS_SA_PROJECT_ID", "gcp-sa-firebasemods");
+    const saEmail = `service-${projectNumber}@${firexSaProjectId}.iam.gserviceaccount.com`;
+    return secretManagerApi.grantServiceAgentRole(secret, saEmail, "roles/secretmanager.admin");
+}
+exports.grantFirexServiceAgentSecretAdminRole = grantFirexServiceAgentSecretAdminRole;
+async function getManagedSecrets(instance) {
+    return (await Promise.all(getActiveSecrets(instance).map(async (secretResourceName) => {
+        const secret = secretManagerApi.parseSecretResourceName(secretResourceName);
+        const labels = await secretManagerApi.getSecretLabels(secret.projectId, secret.name);
+        if (labels && labels[SECRET_LABEL]) {
+            return secretResourceName;
+        }
+        return Promise.resolve("");
+    }))).filter((secretId) => !!secretId);
+}
+exports.getManagedSecrets = getManagedSecrets;
+function getActiveSecrets(instance) {
+    return instance.config.source.spec.params
+        .map((p) => p.type == extensionsApi.ParamType.SECRET && instance.config.params[p.param])
+        .filter((pv) => !!pv);
+}
+function getSecretLabels(instanceId) {
+    const labels = {};
+    labels[SECRET_LABEL] = instanceId;
+    return labels;
+}
+exports.getSecretLabels = getSecretLabels;
+function prettySecretName(secretResourceName) {
+    const nameTokens = secretResourceName.split("/");
+    if (nameTokens.length != 4 && nameTokens.length != 6) {
+        logger_1.logger.debug(`unable to parse secret secretResourceName: ${secretResourceName}`);
+        return secretResourceName;
+    }
+    return nameTokens.slice(0, 4).join("/");
+}
+exports.prettySecretName = prettySecretName;