firebase-tools 14.3.1 → 14.5.0

package/lib/config.js

@@ -156,11 +156,20 @@ class Config {
         }
     }
     writeProjectFile(p, content) {
-        if (typeof content !== "string") {
-            content = JSON.stringify(content, null, 2) + "\n";
+        const path = this.path(p);
+        fs.ensureFileSync(path);
+        fs.writeFileSync(path, stringifyContent(content), "utf8");
+        switch (p) {
+            case "firebase.json":
+                utils.logSuccess("Wrote configuration info to " + clc.bold("firebase.json"));
+                break;
+            case ".firebaserc":
+                utils.logSuccess("Wrote project information to " + clc.bold(".firebaserc"));
+                break;
+            default:
+                utils.logSuccess("Wrote " + clc.bold(p));
+                break;
         }
-        fs.ensureFileSync(this.path(p));
-        fs.writeFileSync(this.path(p), content, "utf8");
     }
     projectFileExists(p) {
         return fs.existsSync(this.path(p));
@@ -168,32 +177,35 @@ class Config {
     deleteProjectFile(p) {
         fs.removeSync(this.path(p));
     }
-    async askWriteProjectFile(path, content, force, confirmByDefault) {
+    async confirmWriteProjectFile(path, content, confirmByDefault) {
         const writeTo = this.path(path);
-        let next = true;
-        if (typeof content !== "string") {
-            content = JSON.stringify(content, null, 2) + "\n";
-        }
-        let existingContent;
-        if (fsutils.fileExistsSync(writeTo)) {
-            existingContent = fsutils.readFile(writeTo);
-        }
-        if (existingContent && existingContent !== content && !force) {
-            next = await (0, prompt_1.confirm)({
-                message: "File " + clc.underline(path) + " already exists. Overwrite?",
-                default: !!confirmByDefault,
-            });
+        if (!fsutils.fileExistsSync(writeTo)) {
+            return true;
         }
-        if (existingContent === content) {
+        const existingContent = fsutils.readFile(writeTo);
+        const newContent = stringifyContent(content);
+        if (existingContent === newContent) {
             utils.logBullet(clc.bold(path) + " is unchanged");
+            return false;
         }
-        else if (next) {
-            this.writeProjectFile(path, content);
-            utils.logSuccess("Wrote " + clc.bold(path));
-        }
-        else {
+        const shouldWrite = await (0, prompt_1.confirm)({
+            message: "File " + clc.underline(path) + " already exists. Overwrite?",
+            default: !!confirmByDefault,
+        });
+        if (!shouldWrite) {
             utils.logBullet("Skipping write of " + clc.bold(path));
+            return false;
         }
+        return true;
+    }
+    async askWriteProjectFile(path, content, force, confirmByDefault) {
+        if (!force) {
+            const shouldWrite = await this.confirmWriteProjectFile(path, content, confirmByDefault);
+            if (!shouldWrite) {
+                return;
+            }
+        }
+        this.writeProjectFile(path, content);
     }
     static load(options, allowMissing) {
         const pd = (0, detectProjectRoot_1.detectProjectRoot)(options);
@@ -239,4 +251,11 @@ Config.MATERIALIZE_TARGETS = [
     "storage",
     "remoteconfig",
     "dataconnect",
+    "apphosting",
 ];
+function stringifyContent(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    return JSON.stringify(content, null, 2) + "\n";
+}

package/lib/crashlytics/listTopIssues.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listTopIssues = void 0;
+const apiv2_1 = require("../apiv2");
+const logger_1 = require("../logger");
+const error_1 = require("../error");
+const api_1 = require("../api");
+const TIMEOUT = 10000;
+const apiClient = new apiv2_1.Client({
+    urlPrefix: (0, api_1.crashlyticsApiOrigin)(),
+    apiVersion: "v1alpha",
+});
+async function listTopIssues(projectId, appId, issueCount) {
+    try {
+        const queryParams = new URLSearchParams();
+        queryParams.set("page_size", `${issueCount}`);
+        const requestProjectId = parseProjectId(appId);
+        if (requestProjectId === undefined) {
+            throw new error_1.FirebaseError("Unable to get the projectId from the AppId.");
+        }
+        const response = await apiClient.request({
+            method: "GET",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            path: `/projects/${requestProjectId}/apps/${appId}/reports/topIssues`,
+            queryParams: queryParams,
+            timeout: TIMEOUT,
+        });
+        return response.body;
+    }
+    catch (err) {
+        logger_1.logger.debug(err.message);
+        throw new error_1.FirebaseError(`Failed to fetch the top issues for the Firebase Project ${projectId}, AppId ${appId}. Error: ${err}.`, { original: err });
+    }
+}
+exports.listTopIssues = listTopIssues;
+function parseProjectId(appId) {
+    const appIdParts = appId.split(":");
+    if (appIdParts.length > 1) {
+        return appIdParts[1];
+    }
+    return undefined;
+}

package/lib/dataconnect/cloudAICompanionClient.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callCloudAICompanion = exports.cloudAICompationClient = void 0;
+const apiv2_1 = require("../apiv2");
+const api_1 = require("../api");
+const CLOUD_AI_COMPANION_VERSION = "v1";
+const CLIENT_CONTEXT_NAME_IDENTIFIER = "firebase_vscode";
+const FIREBASE_CHAT_REQUEST_CONTEXT_TYPE_NAME = "type.googleapis.com/google.cloud.cloudaicompanion.v1main.FirebaseChatRequestContext";
+const FDC_SCHEMA_EXPERIENCE_CONTEXT = "/appeco/firebase/fdc-schema-generator";
+const FDC_OPERATION_EXPERIENCE_CONTEXT = "/appeco/firebase/fdc-query-generator";
+const USER_AUTHOR = "USER";
+function cloudAICompationClient() {
+    return new apiv2_1.Client({
+        urlPrefix: (0, api_1.cloudAiCompanionOrigin)(),
+        apiVersion: CLOUD_AI_COMPANION_VERSION,
+        auth: true,
+    });
+}
+exports.cloudAICompationClient = cloudAICompationClient;
+async function callCloudAICompanion(client, vscodeRequest, type) {
+    const request = buildRequest(vscodeRequest, type);
+    const { projectId } = getServiceParts(vscodeRequest.servicePath);
+    const instance = toChatResourceName(projectId);
+    try {
+        const res = await client.post(`${instance}:completeTask`, request);
+        return res.body;
+    }
+    catch (error) {
+        return { output: { messages: [] }, error: error };
+    }
+}
+exports.callCloudAICompanion = callCloudAICompanion;
+function buildRequest({ servicePath, naturalLanguageQuery, chatHistory }, type) {
+    const { serviceId } = getServiceParts(servicePath);
+    const input = {
+        messages: [
+            ...chatHistory,
+            {
+                author: USER_AUTHOR,
+                content: naturalLanguageQuery,
+            },
+        ],
+    };
+    const clientContext = {
+        name: CLIENT_CONTEXT_NAME_IDENTIFIER,
+        additionalContext: {
+            "@type": FIREBASE_CHAT_REQUEST_CONTEXT_TYPE_NAME,
+            fdcInfo: {
+                serviceId,
+                fdcServiceName: servicePath,
+                requiresQuery: true,
+            },
+        },
+    };
+    return {
+        input,
+        clientContext,
+        experienceContext: {
+            experience: type === "schema" ? FDC_SCHEMA_EXPERIENCE_CONTEXT : FDC_OPERATION_EXPERIENCE_CONTEXT,
+        },
+    };
+}
+function toChatResourceName(projectId) {
+    return `projects/${projectId}/locations/global/instances/default`;
+}
+function getServiceParts(name) {
+    const match = name.match(/projects\/([^/]*)\/locations\/([^/]*)\/services\/([^/]*)/);
+    if (!match) {
+        throw new Error(`Invalid service name: ${name}`);
+    }
+    return { projectId: match[1], locationId: match[2], serviceId: match[3] };
+}

package/lib/dataconnect/cloudAICompanionTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/dataconnect/fileUtils.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getFrameworksFromPackageJson = exports.frameworksMap = exports.SUPPORTED_FRAMEWORKS = exports.resolvePackageJson = exports.getPlatformFromFolder = exports.pickService = exports.readGQLFiles = exports.readConnectorYaml = exports.readDataConnectYaml = exports.readFirebaseJson = void 0;
 const fs = require("fs-extra");
 const path = require("path");
+const clc = require("colorette");
 const error_1 = require("../error");
 const types_1 = require("./types");
 const utils_1 = require("../utils");
@@ -77,10 +78,16 @@ async function pickService(projectId, config, serviceId) {
     const serviceCfgs = readFirebaseJson(config);
     let serviceInfo;
     if (serviceCfgs.length === 0) {
-        throw new error_1.FirebaseError("No Data Connect services found in firebase.json.");
+        throw new error_1.FirebaseError("No Data Connect services found in firebase.json." +
+            `\nYou can run ${clc.bold("firebase init dataconnect")} to add a Data Connect service.`);
     }
     else if (serviceCfgs.length === 1) {
         serviceInfo = await (0, load_1.load)(projectId, config, serviceCfgs[0].source);
+        if (serviceId && serviceId !== serviceInfo.dataConnectYaml.serviceId) {
+            throw new error_1.FirebaseError(`No service named ${serviceId} declared in firebase.json. Found ${serviceInfo.dataConnectYaml.serviceId}.` +
+                `\nYou can run ${clc.bold("firebase init dataconnect")} to add this Data Connect service.`);
+        }
+        return serviceInfo;
     }
     else {
         if (!serviceId) {
@@ -89,11 +96,11 @@ async function pickService(projectId, config, serviceId) {
         const infos = await Promise.all(serviceCfgs.map((c) => (0, load_1.load)(projectId, config, c.source)));
         const maybe = infos.find((i) => i.dataConnectYaml.serviceId === serviceId);
         if (!maybe) {
-            throw new error_1.FirebaseError(`No service named ${serviceId} declared in firebase.json.`);
+            throw new error_1.FirebaseError(`No service named ${serviceId} declared in firebase.json. Found ${infos.map((i) => i.dataConnectYaml.serviceId).join(", ")}.` +
+                `\nYou can run ${clc.bold("firebase init dataconnect")} to add this Data Connect service.`);
         }
-        serviceInfo = maybe;
+        return maybe;
     }
-    return serviceInfo;
 }
 exports.pickService = pickService;
 const WEB_INDICATORS = ["package.json", "package-lock.json", "node_modules"];

package/lib/dataconnect/schemaMigration.js

@@ -29,6 +29,7 @@ async function setupSchemaIfNecessary(instanceId, databaseId, options) {
     return schemaInfo.setupStatus;
 }
 async function diffSchema(options, schema, schemaValidation) {
+    (0, utils_1.logLabeledBullet)("dataconnect", `generating required schema changes...`);
     const { serviceName, instanceName, databaseId, instanceId } = getIdentifiers(schema);
     await ensureServiceIsConnectedToCloudSql(serviceName, instanceName, databaseId, false);
     let diffs = [];
@@ -36,15 +37,12 @@ async function diffSchema(options, schema, schemaValidation) {
     let validationMode = schemaValidation !== null && schemaValidation !== void 0 ? schemaValidation : "COMPATIBLE";
     setSchemaValidationMode(schema, validationMode);
     try {
-        if (!schemaValidation) {
-            (0, utils_1.logLabeledBullet)("dataconnect", `generating required schema changes...`);
-        }
         await (0, client_1.upsertSchema)(schema, true);
         if (validationMode === "STRICT") {
-            (0, utils_1.logLabeledSuccess)("dataconnect", `Database schema is up to date.`);
+            (0, utils_1.logLabeledSuccess)("dataconnect", `database schema of ${instanceId}:${databaseId} is up to date.`);
         }
         else {
-            (0, utils_1.logLabeledSuccess)("dataconnect", `Database schema is compatible.`);
+            (0, utils_1.logLabeledSuccess)("dataconnect", `database schema of ${instanceId}:${databaseId} is compatible.`);
         }
     }
     catch (err) {
@@ -97,6 +95,7 @@ async function diffSchema(options, schema, schemaValidation) {
 }
 exports.diffSchema = diffSchema;
 async function migrateSchema(args) {
+    (0, utils_1.logLabeledBullet)("dataconnect", `generating required schema changes...`);
     const { options, schema, validateOnly, schemaValidation } = args;
     const { serviceName, instanceId, instanceName, databaseId } = getIdentifiers(schema);
     await ensureServiceIsConnectedToCloudSql(serviceName, instanceName, databaseId, true);
@@ -107,7 +106,7 @@ async function migrateSchema(args) {
     setSchemaValidationMode(schema, validationMode);
     try {
         await (0, client_1.upsertSchema)(schema, validateOnly);
-        logger_1.logger.debug(`Database schema was up to date for ${instanceId}:${databaseId}`);
+        (0, utils_1.logLabeledBullet)("dataconnect", `database schema of ${instanceId}:${databaseId} is up to date.`);
     }
     catch (err) {
         if ((err === null || err === void 0 ? void 0 : err.status) !== 400) {
@@ -355,7 +354,7 @@ async function ensureServiceIsConnectedToCloudSql(serviceName, instanceId, datab
             (0, utils_1.logLabeledWarning)("dataconnect", `Not yet linked to the Cloud SQL instance.`);
             return;
         }
-        (0, utils_1.logLabeledBullet)("dataconnect", `Linking the Cloud SQL instance...`);
+        (0, utils_1.logLabeledBullet)("dataconnect", `linking the Cloud SQL instance...`);
         currentSchema = {
             name: `${serviceName}/schemas/${types_1.SCHEMA_ID}`,
             source: {

package/lib/deploy/apphosting/args.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/deploy/apphosting/deploy.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("fs");
+const path = require("path");
+const error_1 = require("../../error");
+const gcs = require("../../gcp/storage");
+const getProjectNumber_1 = require("../../getProjectNumber");
+const projectUtils_1 = require("../../projectUtils");
+const utils_1 = require("../../utils");
+const util_1 = require("./util");
+async function default_1(context, options) {
+    if (context.backendConfigs.size === 0) {
+        return;
+    }
+    const projectId = (0, projectUtils_1.needProjectId)(options);
+    options.projectNumber = await (0, getProjectNumber_1.getProjectNumber)(options);
+    if (!context.backendConfigs) {
+        return;
+    }
+    for (const loc of context.backendLocations.values()) {
+        const bucketName = `firebaseapphosting-sources-${options.projectNumber}-${loc.toLowerCase()}`;
+        try {
+            await gcs.getBucket(bucketName);
+        }
+        catch (err) {
+            const errStatus = (0, error_1.getErrStatus)(err.original);
+            if (errStatus === 403 || errStatus === 404) {
+                (0, utils_1.logLabeledBullet)("apphosting", `Creating Cloud Storage bucket in ${loc} to store App Hosting source code uploads at ${bucketName}...`);
+                try {
+                    await gcs.createBucket(projectId, {
+                        name: bucketName,
+                        location: loc,
+                        lifecycle: {
+                            rule: [
+                                {
+                                    action: {
+                                        type: "Delete",
+                                    },
+                                    condition: {
+                                        age: 30,
+                                    },
+                                },
+                            ],
+                        },
+                    });
+                }
+                catch (err) {
+                    if ((0, error_1.getErrStatus)(err.original) === 403) {
+                        (0, utils_1.logLabeledWarning)("apphosting", "Failed to create Cloud Storage bucket because user does not have sufficient permissions. " +
+                            "See https://cloud.google.com/storage/docs/access-control/iam-roles for more details on " +
+                            "IAM roles that are able to create a Cloud Storage bucket, and ask your project administrator " +
+                            "to grant you one of those roles.");
+                        throw err.original;
+                    }
+                }
+            }
+            else {
+                throw err;
+            }
+        }
+    }
+    for (const cfg of context.backendConfigs.values()) {
+        const { projectSourcePath, zippedSourcePath } = await (0, util_1.createArchive)(cfg, options.projectRoot);
+        const backendLocation = context.backendLocations.get(cfg.backendId);
+        if (!backendLocation) {
+            throw new error_1.FirebaseError(`Failed to find location for backend ${cfg.backendId}. Please contact support with the contents of your firebase-debug.log to report your issue.`);
+        }
+        (0, utils_1.logLabeledBullet)("apphosting", `Uploading source code at ${projectSourcePath} for backend ${cfg.backendId}...`);
+        const { bucket, object } = await gcs.uploadObject({
+            file: zippedSourcePath,
+            stream: fs.createReadStream(zippedSourcePath),
+        }, `firebaseapphosting-sources-${options.projectNumber}-${backendLocation.toLowerCase()}`);
+        (0, utils_1.logLabeledBullet)("apphosting", `Source code uploaded at gs://${bucket}/${object}`);
+        context.backendStorageUris.set(cfg.backendId, `gs://firebaseapphosting-sources-${options.projectNumber}-${backendLocation.toLowerCase()}/${path.basename(zippedSourcePath)}`);
+    }
+}
+exports.default = default_1;

package/lib/deploy/apphosting/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.release = exports.deploy = exports.prepare = void 0;
+const prepare_1 = require("./prepare");
+exports.prepare = prepare_1.default;
+const deploy_1 = require("./deploy");
+exports.deploy = deploy_1.default;
+const release_1 = require("./release");
+exports.release = release_1.default;

package/lib/deploy/apphosting/prepare.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBackendConfigs = void 0;
+const path = require("path");
+const backend_1 = require("../../apphosting/backend");
+const apphosting_1 = require("../../gcp/apphosting");
+const devConnect_1 = require("../../gcp/devConnect");
+const projectUtils_1 = require("../../projectUtils");
+const prompt_1 = require("../../prompt");
+const utils_1 = require("../../utils");
+async function default_1(context, options) {
+    var _a;
+    const projectId = (0, projectUtils_1.needProjectId)(options);
+    await (0, apphosting_1.ensureApiEnabled)(options);
+    await (0, backend_1.ensureRequiredApisEnabled)(projectId);
+    try {
+        await (0, backend_1.ensureAppHostingComputeServiceAccount)(projectId, "", true);
+    }
+    catch (err) {
+        if (err.status === 400) {
+            (0, utils_1.logLabeledWarning)("apphosting", "Your App Hosting compute service account is still being provisioned. Please try again in a few moments.");
+        }
+        throw err;
+    }
+    context.backendConfigs = new Map();
+    context.backendLocations = new Map();
+    context.backendStorageUris = new Map();
+    const configs = getBackendConfigs(options);
+    const { backends } = await (0, apphosting_1.listBackends)(projectId, "-");
+    const foundBackends = [];
+    const notFoundBackends = [];
+    const ambiguousBackends = [];
+    const skippedBackends = [];
+    for (const cfg of configs) {
+        const filteredBackends = backends.filter((backend) => (0, apphosting_1.parseBackendName)(backend.name).id === cfg.backendId);
+        if (filteredBackends.length === 0) {
+            notFoundBackends.push(cfg);
+        }
+        else if (filteredBackends.length === 1) {
+            foundBackends.push(cfg);
+        }
+        else {
+            ambiguousBackends.push(cfg);
+        }
+    }
+    for (const cfg of ambiguousBackends) {
+        const filteredBackends = backends.filter((backend) => (0, apphosting_1.parseBackendName)(backend.name).id === cfg.backendId);
+        const locations = filteredBackends.map((b) => (0, apphosting_1.parseBackendName)(b.name).location);
+        (0, utils_1.logLabeledWarning)("apphosting", `You have multiple backends with the same ${cfg.backendId} ID in regions: ${locations.join(", ")}. This is not allowed until we can support more locations. ` +
+            "Please delete and recreate any backends that share an ID with another backend.");
+    }
+    if (foundBackends.length > 0) {
+        (0, utils_1.logLabeledBullet)("apphosting", `Found backend(s) ${foundBackends.map((cfg) => cfg.backendId).join(", ")}`);
+    }
+    for (const cfg of foundBackends) {
+        const filteredBackends = backends.filter((backend) => (0, apphosting_1.parseBackendName)(backend.name).id === cfg.backendId);
+        if (cfg.alwaysDeployFromSource === false) {
+            skippedBackends.push(cfg);
+            continue;
+        }
+        const backend = filteredBackends[0];
+        const { location } = (0, apphosting_1.parseBackendName)(backend.name);
+        if (cfg.alwaysDeployFromSource === undefined && ((_a = backend.codebase) === null || _a === void 0 ? void 0 : _a.repository)) {
+            const { connectionName, id } = (0, devConnect_1.parseGitRepositoryLinkName)(backend.codebase.repository);
+            const gitRepositoryLink = await (0, devConnect_1.getGitRepositoryLink)(projectId, location, connectionName, id);
+            if (!options.force) {
+                const confirmDeploy = await (0, prompt_1.confirm)({
+                    default: true,
+                    message: `${cfg.backendId} is linked to the remote repository at ${gitRepositoryLink.cloneUri}. Are you sure you want to deploy your local source?`,
+                });
+                cfg.alwaysDeployFromSource = confirmDeploy;
+                const configPath = path.join(options.projectRoot || "", "firebase.json");
+                options.config.writeProjectFile(configPath, options.config.src);
+                (0, utils_1.logLabeledBullet)("apphosting", `On future invocations of "firebase deploy", your local source will ${!confirmDeploy ? "not " : ""}be deployed to ${cfg.backendId}. You can edit this setting in your firebase.json at any time.`);
+                if (!confirmDeploy) {
+                    skippedBackends.push(cfg);
+                    continue;
+                }
+            }
+        }
+        context.backendConfigs.set(cfg.backendId, cfg);
+        context.backendLocations.set(cfg.backendId, location);
+    }
+    if (notFoundBackends.length > 0) {
+        if (options.force) {
+            (0, utils_1.logLabeledWarning)("apphosting", `Skipping deployments of backend(s) ${notFoundBackends.map((cfg) => cfg.backendId).join(", ")}; ` +
+                "the backend(s) do not exist yet and we cannot create them for you because you must choose primary regions for each one. " +
+                "Please run 'firebase deploy' without the --force flag, or 'firebase apphosting:backends:create' to create the backend, " +
+                "then retry deployment.");
+            return;
+        }
+        const confirmCreate = await (0, prompt_1.confirm)({
+            default: true,
+            message: `Did not find backend(s) ${notFoundBackends.map((cfg) => cfg.backendId).join(", ")}. Do you want to create them (you'll have the option to select which to create in the next step)?`,
+        });
+        if (confirmCreate) {
+            const selected = await (0, prompt_1.checkbox)({
+                message: "Which backends do you want to create and deploy to?",
+                choices: notFoundBackends.map((cfg) => cfg.backendId),
+            });
+            const selectedBackends = selected.map((id) => notFoundBackends.find((backend) => backend.backendId === id));
+            for (const cfg of selectedBackends) {
+                (0, utils_1.logLabeledBullet)("apphosting", `Creating a new backend ${cfg.backendId}...`);
+                const { location } = await (0, backend_1.doSetupSourceDeploy)(projectId, cfg.backendId);
+                context.backendConfigs.set(cfg.backendId, cfg);
+                context.backendLocations.set(cfg.backendId, location);
+            }
+        }
+        else {
+            skippedBackends.push(...notFoundBackends);
+        }
+    }
+    if (skippedBackends.length > 0) {
+        (0, utils_1.logLabeledWarning)("apphosting", `Skipping deployment of backend(s) ${skippedBackends.map((cfg) => cfg.backendId).join(", ")}.`);
+    }
+    return;
+}
+exports.default = default_1;
+function getBackendConfigs(options) {
+    if (!options.config.src.apphosting) {
+        return [];
+    }
+    const backendConfigs = Array.isArray(options.config.src.apphosting)
+        ? options.config.src.apphosting
+        : [options.config.src.apphosting];
+    if (!options.only) {
+        return backendConfigs;
+    }
+    const selectors = options.only.split(",");
+    const backendIds = [];
+    for (const selector of selectors) {
+        if (selector === "apphosting") {
+            return backendConfigs;
+        }
+        if (selector.startsWith("apphosting:")) {
+            const backendId = selector.replace("apphosting:", "");
+            if (backendId.length > 0) {
+                backendIds.push(backendId);
+            }
+        }
+    }
+    if (backendIds.length === 0) {
+        return [];
+    }
+    return backendConfigs.filter((cfg) => backendIds.includes(cfg.backendId));
+}
+exports.getBackendConfigs = getBackendConfigs;

package/lib/deploy/apphosting/release.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ora = require("ora");
+const api_1 = require("../../api");
+const backend_1 = require("../../apphosting/backend");
+const rollout_1 = require("../../apphosting/rollout");
+const projectUtils_1 = require("../../projectUtils");
+const utils_1 = require("../../utils");
+async function default_1(context, options) {
+    if (context.backendConfigs.size === 0) {
+        return;
+    }
+    const projectId = (0, projectUtils_1.needProjectId)(options);
+    const rollouts = [];
+    const backendIds = [];
+    for (const backendId of context.backendConfigs.keys()) {
+        const config = context.backendConfigs.get(backendId);
+        const location = context.backendLocations.get(backendId);
+        const storageUri = context.backendStorageUris.get(backendId);
+        if (!config || !location || !storageUri) {
+            (0, utils_1.logLabeledWarning)("apphosting", `Failed to find metadata for backend ${backendId}. Please contact support with the contents of your firebase-debug.log to report your issue.`);
+            continue;
+        }
+        backendIds.push(backendId);
+        rollouts.push((0, rollout_1.orchestrateRollout)({
+            projectId,
+            location,
+            backendId,
+            buildInput: {
+                source: {
+                    archive: {
+                        userStorageUri: storageUri,
+                        rootDirectory: config.rootDir,
+                    },
+                },
+            },
+        }));
+    }
+    (0, utils_1.logLabeledBullet)("apphosting", `You may also track the rollout(s) at:\n\t${(0, api_1.consoleOrigin)()}/project/${projectId}/apphosting`);
+    const rolloutsSpinner = ora(`Starting rollout(s) for backend(s) ${Array.from(context.backendConfigs.keys()).join(", ")}; this may take a few minutes. It's safe to exit now.\n`).start();
+    const results = await Promise.allSettled(rollouts);
+    for (let i = 0; i < results.length; i++) {
+        const res = results[i];
+        if (res.status === "fulfilled") {
+            const backend = await (0, backend_1.getBackend)(projectId, backendIds[i]);
+            (0, utils_1.logLabeledSuccess)("apphosting", `Rollout for backend ${backendIds[i]} complete!`);
+            (0, utils_1.logLabeledSuccess)("apphosting", `Your backend is now deployed at:\n\thttps://${backend.uri}`);
+        }
+        else {
+            (0, utils_1.logLabeledWarning)("apphosting", `Rollout for backend ${backendIds[i]} failed.`);
+            (0, utils_1.logLabeledError)("apphosting", res.reason);
+        }
+    }
+    rolloutsSpinner.stop();
+}
+exports.default = default_1;

package/lib/deploy/apphosting/util.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createArchive = void 0;
+const archiver = require("archiver");
+const fs = require("fs");
+const path = require("path");
+const tmp = require("tmp");
+const error_1 = require("../../error");
+const fsAsync = require("../../fsAsync");
+async function createArchive(config, projectRoot) {
+    const tmpFile = tmp.fileSync({ prefix: `${config.backendId}-`, postfix: ".zip" }).name;
+    const fileStream = fs.createWriteStream(tmpFile, {
+        flags: "w",
+        encoding: "binary",
+    });
+    const archive = archiver("zip");
+    if (!projectRoot) {
+        projectRoot = process.cwd();
+    }
+    const ignore = config.ignore || ["node_modules", ".git"];
+    ignore.push("firebase-debug.log", "firebase-debug.*.log");
+    const gitIgnorePatterns = parseGitIgnorePatterns(projectRoot);
+    ignore.push(...gitIgnorePatterns);
+    try {
+        const files = await fsAsync.readdirRecursive({
+            path: projectRoot,
+            ignore: ignore,
+            isGitIgnore: true,
+        });
+        for (const file of files) {
+            const name = path.relative(projectRoot, file.name);
+            archive.file(file.name, {
+                name,
+                mode: file.mode,
+            });
+        }
+        await pipeAsync(archive, fileStream);
+    }
+    catch (err) {
+        throw new error_1.FirebaseError("Could not read source directory. Remove links and shortcuts and try again.", { original: err, exit: 1 });
+    }
+    return { projectSourcePath: projectRoot, zippedSourcePath: tmpFile };
+}
+exports.createArchive = createArchive;
+function parseGitIgnorePatterns(projectRoot, gitIgnorePath = ".gitignore") {
+    const absoluteFilePath = path.resolve(projectRoot, gitIgnorePath);
+    if (!fs.existsSync(absoluteFilePath)) {
+        return [];
+    }
+    const lines = fs
+        .readFileSync(absoluteFilePath)
+        .toString()
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => !line.startsWith("#") && !(line === ""));
+    return lines;
+}
+async function pipeAsync(from, to) {
+    from.pipe(to);
+    await from.finalize();
+    return new Promise((resolve, reject) => {
+        to.on("finish", resolve);
+        to.on("error", reject);
+    });
+}