firebase-tools 14.3.0 → 14.4.0

package/lib/commands/use.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.command = void 0;
+exports.command = exports.setNewActive = void 0;
 const clc = require("colorette");
 const command_1 = require("../command");
 const projects_1 = require("../management/projects");
@@ -30,10 +30,10 @@ function listAliases(options) {
 function verifyMessage(name) {
     return "please verify project " + clc.bold(name) + " exists and you have access.";
 }
-async function setNewActive(projectOrAlias, aliasOpt, options) {
+async function setNewActive(projectOrAlias, aliasOpt, rc, projectRoot) {
     let project;
-    const hasAlias = options.rc.hasProjectAlias(projectOrAlias);
-    const resolvedProject = options.rc.resolveAlias(projectOrAlias);
+    const hasAlias = rc.hasProjectAlias(projectOrAlias);
+    const resolvedProject = rc.resolveAlias(projectOrAlias);
     (0, command_2.validateProjectId)(resolvedProject);
     try {
         project = await (0, projects_1.getProject)(resolvedProject);
@@ -45,24 +45,25 @@ async function setNewActive(projectOrAlias, aliasOpt, options) {
         if (!project) {
             throw new error_1.FirebaseError(`Cannot create alias ${clc.bold(aliasOpt)}, ${verifyMessage(projectOrAlias)}`);
         }
-        options.rc.addProjectAlias(aliasOpt, projectOrAlias);
+        rc.addProjectAlias(aliasOpt, projectOrAlias);
         logger_1.logger.info("Created alias", clc.bold(aliasOpt), "for", resolvedProject + ".");
     }
     if (hasAlias) {
         if (!project) {
             throw new error_1.FirebaseError(`Unable to use alias ${clc.bold(projectOrAlias)}, ${verifyMessage(resolvedProject)}`);
         }
-        utils.makeActiveProject(options.projectRoot, projectOrAlias);
+        utils.makeActiveProject(projectRoot, projectOrAlias);
         logger_1.logger.info("Now using alias", clc.bold(projectOrAlias), "(" + resolvedProject + ")");
     }
     else if (project) {
-        utils.makeActiveProject(options.projectRoot, projectOrAlias);
+        utils.makeActiveProject(projectRoot, projectOrAlias);
         logger_1.logger.info("Now using project", clc.bold(projectOrAlias));
     }
     else {
         throw new error_1.FirebaseError(`Invalid project selection, ${verifyMessage(projectOrAlias)}`);
     }
 }
+exports.setNewActive = setNewActive;
 function unalias(alias, options) {
     if (options.rc.hasProjectAlias(alias)) {
         options.rc.removeProjectAlias(alias);
@@ -150,7 +151,7 @@ exports.command = new command_1.Command("use [alias_or_project_id]")
             " to start a project directory in the current folder.");
     }
     if (newActive) {
-        return setNewActive(newActive, aliasOpt, options);
+        return setNewActive(newActive, aliasOpt, options.rc, options.projectRoot);
     }
     if (options.unalias) {
         return unalias(options.unalias, options);

package/lib/config.js

@@ -239,4 +239,5 @@ Config.MATERIALIZE_TARGETS = [
     "storage",
     "remoteconfig",
     "dataconnect",
+    "apphosting",
 ];

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,67 @@
+"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);
+    const res = await client.post(`${instance}:completeTask`, request);
+    return res;
+}
+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/dataplaneClient.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeGraphQL = exports.dataconnectDataplaneClient = exports.DATACONNECT_API_VERSION = exports.dataconnectOrigin = void 0;
+exports.executeGraphQLMutation = exports.executeGraphQLQuery = exports.executeGraphQLRead = exports.executeGraphQL = exports.dataconnectDataplaneClient = exports.DATACONNECT_API_VERSION = exports.dataconnectOrigin = void 0;
 const api_1 = require("../api");
 var api_2 = require("../api");
 Object.defineProperty(exports, "dataconnectOrigin", { enumerable: true, get: function () { return api_2.dataconnectOrigin; } });
@@ -19,3 +19,18 @@ async function executeGraphQL(client, servicePath, body) {
     return res;
 }
 exports.executeGraphQL = executeGraphQL;
+async function executeGraphQLRead(client, servicePath, body) {
+    const res = await client.post(`${servicePath}:executeGraphqlRead`, body, { resolveOnHTTPError: true });
+    return res;
+}
+exports.executeGraphQLRead = executeGraphQLRead;
+async function executeGraphQLQuery(client, connectorPath, body) {
+    const res = await client.post(`${connectorPath}:executeQuery`, body, { resolveOnHTTPError: true });
+    return res;
+}
+exports.executeGraphQLQuery = executeGraphQLQuery;
+async function executeGraphQLMutation(client, connectorPath, body) {
+    const res = await client.post(`${connectorPath}:executeMutation`, body, { resolveOnHTTPError: true });
+    return res;
+}
+exports.executeGraphQLMutation = executeGraphQLMutation;

package/lib/dataconnect/types.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toDatasource = exports.Platform = exports.requiresVector = exports.SCHEMA_ID = void 0;
+exports.isGraphQLResponseError = exports.isGraphQLResponse = exports.toDatasource = exports.Platform = exports.requiresVector = exports.SCHEMA_ID = void 0;
 exports.SCHEMA_ID = "main";
 function requiresVector(dm) {
     var _a, _b, _c, _d;
@@ -31,3 +31,7 @@ function toDatasource(projectId, locationId, ds) {
     return {};
 }
 exports.toDatasource = toDatasource;
+const isGraphQLResponse = (g) => !!g.data || !!g.errors;
+exports.isGraphQLResponse = isGraphQLResponse;
+const isGraphQLResponseError = (g) => !!g.error;
+exports.isGraphQLResponseError = isGraphQLResponseError;

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,74 @@
+"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) {
+    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,141 @@
+"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 = [];
+    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) {
+            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", `Your deployment preferences have been saved to firebase.json. On future invocations of "firebase deploy", your local source will be deployed to ${cfg.backendId}. You can edit this setting in your firebase.json at any time.`);
+                if (!confirmDeploy) {
+                    (0, utils_1.logLabeledWarning)("apphosting", `Skipping deployment of backend ${cfg.backendId}`);
+                    continue;
+                }
+            }
+        }
+        context.backendConfigs.set(cfg.backendId, cfg);
+        context.backendLocations.set(cfg.backendId, location);
+    }
+    if (notFoundBackends.length === 0) {
+        return;
+    }
+    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) {
+        return;
+    }
+    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);
+    }
+    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,53 @@
+"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) {
+    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);
+    });
+}

package/lib/deploy/extensions/v2FunctionHelper.js

@@ -9,6 +9,7 @@ const ensureApiEnabled_1 = require("../../ensureApiEnabled");
 const planner = require("./planner");
 const projectUtils_1 = require("../../projectUtils");
 const api_1 = require("../../api");
+const computeEngine_1 = require("../../gcp/computeEngine");
 const SERVICE_AGENT_ROLE = "roles/eventarc.eventReceiver";
 async function checkSpecForV2Functions(i) {
     const extensionSpec = await planner.getExtensionSpec(i);
@@ -23,7 +24,7 @@ async function ensureNecessaryV2ApisAndRoles(options) {
 exports.ensureNecessaryV2ApisAndRoles = ensureNecessaryV2ApisAndRoles;
 async function ensureComputeP4SARole(projectId) {
     const projectNumber = await (0, getProjectNumber_1.getProjectNumber)({ projectId });
-    const saEmail = `${projectNumber}-compute@developer.gserviceaccount.com`;
+    const saEmail = await (0, computeEngine_1.getDefaultServiceAccount)(projectNumber);
     let policy;
     try {
         policy = await resourceManager.getIamPolicy(projectId);

package/lib/deploy/functions/checkIam.js

@@ -89,8 +89,8 @@ function obtainPubSubServiceAgentBindings(projectNumber) {
     return [serviceAccountTokenCreatorBinding];
 }
 exports.obtainPubSubServiceAgentBindings = obtainPubSubServiceAgentBindings;
-function obtainDefaultComputeServiceAgentBindings(projectNumber) {
-    const defaultComputeServiceAgent = `serviceAccount:${gce.getDefaultServiceAccount(projectNumber)}`;
+async function obtainDefaultComputeServiceAgentBindings(projectNumber) {
+    const defaultComputeServiceAgent = `serviceAccount:${await gce.getDefaultServiceAccount(projectNumber)}`;
     const runInvokerBinding = {
         role: exports.RUN_INVOKER_ROLE,
         members: [defaultComputeServiceAgent],
@@ -117,7 +117,7 @@ async function ensureServiceAgentRoles(projectId, projectNumber, want, have, dry
     const requiredBindings = [...(0, functional_1.flattenArray)(nestedRequiredBindings)];
     if (haveServices.length === 0) {
         requiredBindings.push(...obtainPubSubServiceAgentBindings(projectNumber));
-        requiredBindings.push(...obtainDefaultComputeServiceAgentBindings(projectNumber));
+        requiredBindings.push(...(await obtainDefaultComputeServiceAgentBindings(projectNumber)));
     }
     if (requiredBindings.length === 0) {
         return;

package/lib/deploy/functions/ensure.js

@@ -10,6 +10,7 @@ const projects_1 = require("../../management/projects");
 const functional_1 = require("../../functional");
 const api_1 = require("../../api");
 const backend = require("./backend");
+const computeEngine_1 = require("../../gcp/computeEngine");
 const FAQ_URL = "https://firebase.google.com/support/faq#functions-runtime";
 const metadataCallCache = new Map();
 async function defaultServiceAccount(e) {
@@ -23,7 +24,7 @@ async function defaultServiceAccount(e) {
         return `${metadata.projectId}@appspot.gserviceaccount.com`;
     }
     else if (e.platform === "gcfv2") {
-        return `${metadata.projectNumber}-compute@developer.gserviceaccount.com`;
+        return await (0, computeEngine_1.getDefaultServiceAccount)(metadata.projectNumber);
     }
     (0, functional_1.assertExhaustive)(e.platform);
 }