firebase-tools 15.17.0 → 15.19.0

package/lib/accountExporter.js

@@ -40,10 +40,16 @@ const PROVIDER_ID_INDEX_MAP = new Map([
     ["facebook.com", 11],
     ["twitter.com", 15],
     ["github.com", 19],
+    ["apple.com", 28],
+    ["microsoft.com", 32],
+    ["gc.apple.com", 36],
+    ["playgames.google.com", 40],
+    ["linkedin.com", 44],
+    ["yahoo.com", 48],
 ]);
-function escapeComma(str) {
-    if (str.includes(",")) {
-        return `"${str}"`;
+function escapeCsv(str) {
+    if (str.includes(",") || str.includes('"') || str.includes("\n") || str.includes("\r")) {
+        return `"${str.replace(/"/g, '""')}"`;
     }
     return str;
 }
@@ -53,17 +59,18 @@ function convertToNormalBase64(data) {
 function addProviderUserInfo(providerInfo, arr, startPos) {
     arr[startPos] = providerInfo.rawId;
     arr[startPos + 1] = providerInfo.email || "";
-    arr[startPos + 2] = escapeComma(providerInfo.displayName || "");
+    arr[startPos + 2] = escapeCsv(providerInfo.displayName || "");
     arr[startPos + 3] = providerInfo.photoUrl || "";
 }
 function transUserToArray(user) {
-    const arr = Array(27).fill("");
+    const arrLength = Math.max(...PROVIDER_ID_INDEX_MAP.values()) + 4;
+    const arr = Array(arrLength).fill("");
     arr[0] = user.localId;
     arr[1] = user.email || "";
     arr[2] = user.emailVerified || false;
     arr[3] = convertToNormalBase64(user.passwordHash || "");
     arr[4] = convertToNormalBase64(user.salt || "");
-    arr[5] = escapeComma(user.displayName || "");
+    arr[5] = escapeCsv(user.displayName || "");
     arr[6] = user.photoUrl || "";
     for (let i = 0; i < (!user.providerUserInfo ? 0 : user.providerUserInfo.length); i++) {
         const providerInfo = user.providerUserInfo[i];

package/lib/accountImporter.js

@@ -32,7 +32,18 @@ const ALLOWED_JSON_KEYS_RENAMING = {
     lastSignedInAt: "lastLoginAt",
 };
 const ALLOWED_PROVIDER_USER_INFO_KEYS = ["providerId", "rawId", "email", "displayName", "photoUrl"];
-const ALLOWED_PROVIDER_IDS = ["google.com", "facebook.com", "twitter.com", "github.com"];
+const ALLOWED_PROVIDER_IDS = [
+    "google.com",
+    "facebook.com",
+    "twitter.com",
+    "github.com",
+    "apple.com",
+    "microsoft.com",
+    "gc.apple.com",
+    "playgames.google.com",
+    "linkedin.com",
+    "yahoo.com",
+];
 function isValidBase64(str) {
     const expected = Buffer.from(str, "base64").toString("base64");
     if (str.length < expected.length && !str.endsWith("=")) {
@@ -125,6 +136,12 @@ function transArrayToUser(arr) {
     addProviderUserInfo(user, "facebook.com", arr.slice(11, 15));
     addProviderUserInfo(user, "twitter.com", arr.slice(15, 19));
     addProviderUserInfo(user, "github.com", arr.slice(19, 23));
+    addProviderUserInfo(user, "apple.com", arr.slice(28, 32));
+    addProviderUserInfo(user, "microsoft.com", arr.slice(32, 36));
+    addProviderUserInfo(user, "gc.apple.com", arr.slice(36, 40));
+    addProviderUserInfo(user, "playgames.google.com", arr.slice(40, 44));
+    addProviderUserInfo(user, "linkedin.com", arr.slice(44, 48));
+    addProviderUserInfo(user, "yahoo.com", arr.slice(48, 52));
     if (user.passwordHash && !isValidBase64(user.passwordHash)) {
         return {
             error: "Password hash should be base64 encoded.",

package/lib/apphosting/constants.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ALLOWED_DEPLOY_METHODS = exports.DEFAULT_DEPLOY_METHOD = exports.DEFAULT_LOCATION = void 0;
+exports.LOCAL_BUILD_DIR_NAME = exports.ALLOWED_DEPLOY_METHODS = exports.DEFAULT_DEPLOY_METHOD = exports.DEFAULT_LOCATION = void 0;
 exports.DEFAULT_LOCATION = "us-east4";
 exports.DEFAULT_DEPLOY_METHOD = "github";
 exports.ALLOWED_DEPLOY_METHODS = [{ name: "Deploy using github", value: "github" }];
+exports.LOCAL_BUILD_DIR_NAME = ".local_build";

package/lib/apphosting/localbuilds.js

@@ -1,11 +1,102 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.runUniversalMaker = runUniversalMaker;
 exports.localBuild = localBuild;
-const build_1 = require("@apphosting/build");
-const secrets_1 = require("./secrets");
+const childProcess = require("child_process");
+const fs = require("fs-extra");
+const path = require("path");
+const index_1 = require("./secrets/index");
 const prompt_1 = require("../prompt");
 const error_1 = require("../error");
-async function localBuild(projectId, projectRoot, framework, env = {}, options) {
+const logger_1 = require("../logger");
+const utils_1 = require("../utils");
+const universalMakerDownload_1 = require("./universalMakerDownload");
+async function runUniversalMaker(projectRoot, addedEnv) {
+    const universalMakerBinary = await (0, universalMakerDownload_1.getOrDownloadUniversalMaker)();
+    executeUniversalMakerBinary(universalMakerBinary, projectRoot, addedEnv);
+    return processUniversalMakerOutput(projectRoot);
+}
+function executeUniversalMakerBinary(universalMakerBinary, projectRoot, addedEnv) {
+    try {
+        const targetAppHosting = path.join(projectRoot, ".apphosting");
+        fs.removeSync(targetAppHosting);
+        fs.ensureDirSync(targetAppHosting);
+        const res = childProcess.spawnSync(universalMakerBinary, ["-application_dir", projectRoot, "-output_dir", projectRoot, "-output_format", "json"], {
+            cwd: projectRoot,
+            env: {
+                ...process.env,
+                ...addedEnv,
+                X_GOOGLE_TARGET_PLATFORM: "fah",
+                FIREBASE_OUTPUT_BUNDLE_DIR: targetAppHosting,
+            },
+            stdio: "pipe",
+        });
+        if (res.stdout) {
+            logger_1.logger.debug("[Universal Maker stdout]:\n" + res.stdout.toString());
+        }
+        if (res.stderr) {
+            logger_1.logger.debug("[Universal Maker stderr]:\n" + res.stderr.toString());
+        }
+        if (res.error) {
+            throw res.error;
+        }
+        if (res.status !== 0) {
+            throw new error_1.FirebaseError(`Universal Maker failed with exit code ${res.status ?? "unknown"}.`);
+        }
+    }
+    catch (e) {
+        if (e && typeof e === "object" && "code" in e && e.code === "EACCES") {
+            throw new error_1.FirebaseError(`Failed to execute the Universal Maker binary at ${universalMakerBinary} due to permission constraints. Please assure you have set execution permissions (e.g., chmod +x) on the file.`);
+        }
+        throw e;
+    }
+}
+function parseBundleYaml(projectRoot, defaultRunCommand) {
+    const bundleYamlPath = path.join(projectRoot, ".apphosting", "bundle.yaml");
+    if (!fs.existsSync(bundleYamlPath)) {
+        throw new error_1.FirebaseError("Failed to resolve build artifacts. Ensure Universal Maker produced a valid bundle.yaml with outputFiles.");
+    }
+    const bundleRaw = fs.readFileSync(bundleYamlPath, "utf-8");
+    const bundleData = (0, utils_1.wrappedSafeLoad)(bundleRaw);
+    const runCommand = bundleData?.runConfig?.runCommand ?? defaultRunCommand;
+    const outputFiles = bundleData?.outputFiles?.serverApp?.include ?? [];
+    return { runCommand, outputFiles };
+}
+function processUniversalMakerOutput(projectRoot) {
+    const outputFilePath = path.join(projectRoot, "build_output.json");
+    if (!fs.existsSync(outputFilePath)) {
+        throw new error_1.FirebaseError(`Universal Maker did not produce the expected output file at ${outputFilePath}`);
+    }
+    const outputRaw = fs.readFileSync(outputFilePath, "utf-8");
+    fs.unlinkSync(outputFilePath);
+    let umOutput;
+    try {
+        umOutput = JSON.parse(outputRaw);
+    }
+    catch (e) {
+        throw new error_1.FirebaseError(`Failed to parse build_output.json: ${(0, error_1.getErrMsg)(e)}`);
+    }
+    const defaultRunCommand = `${umOutput.command} ${umOutput.args.join(" ")}`;
+    const { runCommand: finalRunCommand, outputFiles: finalOutputFiles } = parseBundleYaml(projectRoot, defaultRunCommand);
+    return {
+        runConfig: {
+            runCommand: finalRunCommand,
+            environmentVariables: Object.entries(umOutput.envVars || {})
+                .filter(([k]) => k !== "FIREBASE_OUTPUT_BUNDLE_DIR")
+                .map(([k, v]) => ({
+                variable: k,
+                value: String(v),
+                availability: ["RUNTIME"],
+            })),
+        },
+        outputFiles: {
+            serverApp: {
+                include: finalOutputFiles,
+            },
+        },
+    };
+}
+async function localBuild(projectId, projectRoot, env = {}, options) {
     const hasBuildAvailableSecrets = Object.values(env).some((v) => v.secret && (!v.availability || v.availability.includes("BUILD")));
     if (hasBuildAvailableSecrets && !options?.allowLocalBuildSecrets) {
         if (options?.nonInteractive) {
@@ -18,34 +109,15 @@ async function localBuild(projectId, projectRoot, framework, env = {}, options)
             throw new error_1.FirebaseError("Cancelled local build due to BUILD-available secrets.");
         }
     }
-    const originalEnv = { ...process.env };
     const addedEnv = await toProcessEnv(projectId, env);
-    for (const [key, value] of Object.entries(addedEnv)) {
-        process.env[key] = value;
-    }
-    let apphostingBuildOutput;
-    try {
-        apphostingBuildOutput = await (0, build_1.localBuild)(projectRoot, framework);
-    }
-    finally {
-        for (const key in process.env) {
-            if (!(key in originalEnv)) {
-                delete process.env[key];
-            }
-        }
-        for (const [key, value] of Object.entries(originalEnv)) {
-            process.env[key] = value;
-        }
-    }
-    const annotations = Object.fromEntries(Object.entries(apphostingBuildOutput.metadata).map(([key, value]) => [key, String(value)]));
+    const apphostingBuildOutput = await runUniversalMaker(projectRoot, addedEnv);
     const discoveredEnv = apphostingBuildOutput.runConfig.environmentVariables?.map(({ variable, value, availability }) => ({
         variable,
         value,
-        availability,
+        availability: availability,
     }));
     return {
         outputFiles: apphostingBuildOutput.outputFiles?.serverApp.include ?? [],
-        annotations,
         buildConfig: {
             runCommand: apphostingBuildOutput.runConfig.runCommand,
             env: discoveredEnv ?? [],
@@ -53,18 +125,14 @@ async function localBuild(projectId, projectRoot, framework, env = {}, options)
     };
 }
 async function toProcessEnv(projectId, env) {
-    const entries = await Promise.all(Object.entries(env).map(async ([key, value]) => {
-        if (value.availability && !value.availability.includes("BUILD")) {
-            return null;
-        }
-        if (value.secret) {
-            const resolvedValue = await (0, secrets_1.loadSecret)(projectId, value.secret);
-            return [key, resolvedValue];
-        }
-        else {
-            return [key, value.value || ""];
-        }
+    const buildVars = Object.entries(env).filter(([, value]) => {
+        return !value.availability || value.availability.includes("BUILD");
+    });
+    const resolvedEntries = await Promise.all(buildVars.map(async ([key, value]) => {
+        const resolvedValue = value.secret
+            ? await (0, index_1.loadSecret)(projectId, value.secret)
+            : value.value || "";
+        return [key, resolvedValue];
     }));
-    const filteredEntries = entries.filter((entry) => entry !== null);
-    return Object.fromEntries(filteredEntries);
+    return Object.fromEntries(resolvedEntries);
 }

package/lib/apphosting/universalMakerDownload.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOrDownloadUniversalMaker = getOrDownloadUniversalMaker;
+const fs = require("fs-extra");
+const os = require("os");
+const path = require("path");
+const error_1 = require("../error");
+const downloadUtils = require("../downloadUtils");
+const logger_1 = require("../logger");
+const universalMakerInfo = require("./universalMakerInfo.json");
+const CACHE_DIR = path.join(os.homedir(), ".cache", "firebase", "universal-maker");
+const UNIVERSAL_MAKER_UPDATE_DETAILS = universalMakerInfo;
+function getPlatformInfo() {
+    let platformKey = "";
+    if (process.platform === "darwin") {
+        if (process.arch === "arm64") {
+            platformKey = "darwin_arm64";
+        }
+        else {
+            throw new error_1.FirebaseError("macOS Intel (darwin_x64) is not currently supported for Universal Maker.");
+        }
+    }
+    else if (process.platform === "linux") {
+        if (process.arch === "x64") {
+            platformKey = "linux_x64";
+        }
+        else {
+            throw new error_1.FirebaseError("Linux ARM (linux_arm64) is not currently supported for Universal Maker.");
+        }
+    }
+    else if (process.platform === "win32") {
+        throw new error_1.FirebaseError("Windows (win32) is not currently supported for Universal Maker.");
+    }
+    else {
+        throw new error_1.FirebaseError(`Unsupported platform for Universal Maker: ${process.platform} ${process.arch}`);
+    }
+    const details = UNIVERSAL_MAKER_UPDATE_DETAILS[platformKey];
+    if (!details) {
+        throw new error_1.FirebaseError(`Could not find download details for platform: ${platformKey}`);
+    }
+    return details;
+}
+async function getOrDownloadUniversalMaker() {
+    const details = getPlatformInfo();
+    const downloadPath = path.join(CACHE_DIR, details.downloadPathRelativeToCacheDir);
+    const hasBinary = fs.existsSync(downloadPath);
+    if (hasBinary) {
+        logger_1.logger.debug(`[apphosting] Universal Maker binary found at cache: ${downloadPath}`);
+        try {
+            await downloadUtils.validateSize(downloadPath, details.expectedSize);
+            await downloadUtils.validateChecksum(downloadPath, details.expectedChecksumSHA256, "sha256");
+            return downloadPath;
+        }
+        catch (err) {
+            logger_1.logger.warn(`[apphosting] Cached Universal Maker binary failed verification: ${err.message}. Proceeding to redownload...`);
+        }
+    }
+    logger_1.logger.info("Downloading Universal Maker, a tool required to build your App Hosting application locally...");
+    fs.ensureDirSync(CACHE_DIR);
+    let tmpfile;
+    try {
+        tmpfile = await downloadUtils.downloadToTmp(details.remoteUrl);
+    }
+    catch (err) {
+        throw new error_1.FirebaseError(`Failed to download Universal Maker: ${err.message}`);
+    }
+    await downloadUtils.validateSize(tmpfile, details.expectedSize);
+    await downloadUtils.validateChecksum(tmpfile, details.expectedChecksumSHA256, "sha256");
+    fs.copySync(tmpfile, downloadPath);
+    fs.chmodSync(downloadPath, 0o755);
+    return downloadPath;
+}

package/lib/apphosting/universalMakerInfo.json

@@ -0,0 +1,16 @@
+{
+    "darwin_arm64": {
+        "version": "1.0.0",
+        "expectedSize": 16266914,
+        "expectedChecksumSHA256": "72dae4eeefedc096649134f6ee592248c17dba5cdaec5bf679f367b2093d41cc",
+        "remoteUrl": "https://artifactregistry.googleapis.com/download/v1/projects/serverless-runtimes-qa/locations/us-central1/repositories/universal-maker/files/darwin-arm64%3A1.0.0%3Auniversal_maker:download?alt=media",
+        "downloadPathRelativeToCacheDir": "universal-maker-darwin-arm64-1.0.0"
+    },
+    "linux_x64": {
+        "version": "1.0.0",
+        "expectedSize": 17023802,
+        "expectedChecksumSHA256": "ba74d2d2ce61d1b773f5b9eefeb09ef48a6890f2767581b57f9871869693823d",
+        "remoteUrl": "https://artifactregistry.googleapis.com/download/v1/projects/serverless-runtimes-qa/locations/us-central1/repositories/universal-maker/files/x86-64%3A1.0.0%3Auniversal_maker:download?alt=media",
+        "downloadPathRelativeToCacheDir": "universal-maker-linux-x64-1.0.0"
+    }
+}

package/lib/archiveDirectory.js

@@ -43,7 +43,7 @@ async function zipDirectory(sourceDirectory, tempFile, options) {
     try {
         files = await fsAsync.readdirRecursive({
             path: sourceDirectory,
-            ignore: options.ignore,
+            ignoreStrings: options.ignore,
             ignoreSymlinks: true,
         });
     }

package/lib/commands/dataconnect-sql-shell.js

@@ -103,6 +103,9 @@ exports.command = new command_1.Command("dataconnect:sql:shell")
         user: username,
         database: databaseId,
     });
+    pool.on("error", (err) => {
+        logger_1.logger.debug("PostgreSQL pool error:", err);
+    });
     const conn = await pool.connect();
     await conn.query(`SET search_path TO "${schemaName}"`);
     logger_1.logger.info(`Logged in as ${username}`);
@@ -110,8 +113,23 @@ exports.command = new command_1.Command("dataconnect:sql:shell")
     logger_1.logger.info(clc.gray("Type your your SQL query or '.exit' to quit, queries should end with ';' or add empty line to execute."));
     await mainShellLoop(conn);
     logger_1.logger.info(clc.yellow("Exiting shell..."));
-    conn.release();
-    await pool.end();
-    connector.close();
+    try {
+        conn.release();
+    }
+    catch (err) {
+        logger_1.logger.debug("Error releasing pg connection:", err);
+    }
+    try {
+        connector.close();
+    }
+    catch (err) {
+        logger_1.logger.debug("Error closing Cloud SQL connector:", err);
+    }
+    try {
+        await pool.end();
+    }
+    catch (err) {
+        logger_1.logger.debug("Error ending pg pool:", err);
+    }
     return { projectId };
 });

package/lib/deploy/apphosting/deploy.js

@@ -10,6 +10,7 @@ const projectUtils_1 = require("../../projectUtils");
 const utils_1 = require("../../utils");
 const util = require("./util");
 const experiments = require("../../experiments");
+const logger_1 = require("../../logger");
 async function default_1(context, options) {
     if (Object.entries(context.backendConfigs).length === 0) {
         return;
@@ -52,31 +53,46 @@ async function default_1(context, options) {
     }));
     await Promise.all(Object.values(context.backendConfigs).map(async (cfg) => {
         const rootDir = options.projectRoot ?? process.cwd();
-        let builtAppDir;
-        const isLocalBuild = !!cfg.localBuild;
-        if (isLocalBuild) {
-            experiments.assertEnabled("apphostinglocalbuilds", "App Hosting local builds");
-            builtAppDir = context.backendLocalBuilds[cfg.backendId].buildDir;
-            if (!builtAppDir) {
-                throw new error_1.FirebaseError(`No local build dir found for ${cfg.backendId}`);
+        let localBuildScratchDir;
+        try {
+            const isLocalBuild = cfg.localBuild;
+            let outputFiles;
+            if (isLocalBuild) {
+                experiments.assertEnabled("apphostinglocalbuilds", "App Hosting local builds");
+                const localBuild = context.backendLocalBuilds[cfg.backendId];
+                outputFiles = localBuild?.outputFiles;
+                localBuildScratchDir = localBuild?.localBuildScratchDir;
+                if (!outputFiles || !localBuildScratchDir) {
+                    throw new error_1.FirebaseError(`No local build output files found for ${cfg.backendId}`);
+                }
             }
+            const zippedSourcePath = isLocalBuild
+                ? await util.createLocalBuildTarArchive(cfg, localBuildScratchDir, outputFiles ?? [])
+                : await util.createSourceDeployArchive(cfg, rootDir);
+            (0, utils_1.logLabeledBullet)("apphosting", `Zipped ${isLocalBuild ? "built app" : "source"} for backend ${cfg.backendId}`);
+            const backendLocation = context.backendLocations[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 ${isLocalBuild ? "built app" : "source"} for backend ${cfg.backendId}...`);
+            const bucketName = bucketsPerLocation[backendLocation];
+            const { bucket, object } = await gcs.uploadObject({
+                file: zippedSourcePath,
+                stream: fs.createReadStream(zippedSourcePath),
+            }, bucketName, isLocalBuild ? gcs.ContentType.TAR : gcs.ContentType.ZIP);
+            (0, utils_1.logLabeledBullet)("apphosting", `Uploaded at gs://${bucket}/${object}`);
+            context.backendStorageUris[cfg.backendId] =
+                `gs://${bucketName}/${path.basename(zippedSourcePath)}`;
         }
-        const zippedSourcePath = isLocalBuild
-            ? await util.createLocalBuildTarArchive(cfg, rootDir, builtAppDir)
-            : await util.createSourceDeployArchive(cfg, rootDir);
-        (0, utils_1.logLabeledBullet)("apphosting", `Zipped ${isLocalBuild ? "built app" : "source"} for backend ${cfg.backendId}`);
-        const backendLocation = context.backendLocations[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.`);
+        finally {
+            if (localBuildScratchDir && fs.existsSync(localBuildScratchDir)) {
+                try {
+                    fs.rmSync(localBuildScratchDir, { recursive: true, force: true });
+                }
+                catch (err) {
+                    logger_1.logger.debug(`Failed to clean up local build directory ${localBuildScratchDir}: ${err}`);
+                }
+            }
         }
-        (0, utils_1.logLabeledBullet)("apphosting", `Uploading ${isLocalBuild ? "built app" : "source"} for backend ${cfg.backendId}...`);
-        const bucketName = bucketsPerLocation[backendLocation];
-        const { bucket, object } = await gcs.uploadObject({
-            file: zippedSourcePath,
-            stream: fs.createReadStream(zippedSourcePath),
-        }, bucketName, isLocalBuild ? gcs.ContentType.TAR : gcs.ContentType.ZIP);
-        (0, utils_1.logLabeledBullet)("apphosting", `Uploaded at gs://${bucket}/${object}`);
-        context.backendStorageUris[cfg.backendId] =
-            `gs://${bucketName}/${path.basename(zippedSourcePath)}`;
     }));
 }

package/lib/deploy/apphosting/prepare.js

@@ -4,7 +4,10 @@ exports.default = default_1;
 exports.injectEnvVarsFromApphostingConfig = injectEnvVarsFromApphostingConfig;
 exports.injectAutoInitEnvVars = injectAutoInitEnvVars;
 exports.getBackendConfigs = getBackendConfigs;
+const fs = require("fs");
 const path = require("path");
+const fsAsync = require("../../fsAsync");
+const util_1 = require("./util");
 const backend_1 = require("../../apphosting/backend");
 const apphosting_1 = require("../../gcp/apphosting");
 const yaml_1 = require("../../apphosting/yaml");
@@ -16,6 +19,7 @@ const getProjectNumber_1 = require("../../getProjectNumber");
 const prompt_1 = require("../../prompt");
 const utils_1 = require("../../utils");
 const localbuilds_1 = require("../../apphosting/localbuilds");
+const constants_1 = require("../../apphosting/constants");
 const error_1 = require("../../error");
 const managementApps = require("../../management/apps");
 const utils_2 = require("../../apphosting/utils");
@@ -132,21 +136,21 @@ async function default_1(context, options) {
         (0, utils_1.logLabeledBullet)("apphosting", `Starting local build for backend ${cfg.backendId}`);
         await injectEnvVarsFromApphostingConfig(configs.filter((c) => c.backendId === cfg.backendId), options, buildEnv, runtimeEnv);
         await injectAutoInitEnvVars(cfg, backends, buildEnv, runtimeEnv);
+        const rootDir = options.projectRoot || process.cwd();
+        const localBuildScratchDir = path.join(rootDir, `${constants_1.LOCAL_BUILD_DIR_NAME}_${cfg.backendId}`);
         try {
-            const { outputFiles, annotations, buildConfig } = await (0, localbuilds_1.localBuild)(projectId, options.projectRoot || "./", "nextjs", buildEnv[cfg.backendId] || {}, {
+            await prepareLocalBuildScratchDirectory(rootDir, localBuildScratchDir, cfg);
+            const { outputFiles, buildConfig } = await (0, localbuilds_1.localBuild)(projectId, localBuildScratchDir, buildEnv[cfg.backendId] || {}, {
                 nonInteractive: options.nonInteractive,
                 allowLocalBuildSecrets: !!options.allowLocalBuildSecrets,
             });
-            if (outputFiles.length !== 1) {
-                throw new error_1.FirebaseError(`Local build for backend ${cfg.backendId} failed: No output files found.`);
-            }
             context.backendLocalBuilds[cfg.backendId] = {
-                buildDir: outputFiles[0],
+                outputFiles,
+                localBuildScratchDir,
                 buildConfig: {
                     ...buildConfig,
                     env: mergeEnvVars(buildConfig.env || [], runtimeEnv[cfg.backendId] || {}),
                 },
-                annotations,
             };
         }
         catch (e) {
@@ -244,3 +248,21 @@ async function ensureAppHostingServiceAgentRoles(projectId, projectNumber) {
         (0, utils_1.logLabeledWarning)("apphosting", `Unable to verify App Hosting service agent permissions for ${p4saEmail}. If you encounter a PERMISSION_DENIED error during rollout, please ensure the service agent has the "Storage Object Viewer" role.`);
     }
 }
+async function prepareLocalBuildScratchDirectory(rootDir, localBuildScratchDir, cfg) {
+    const ignore = (0, util_1.resolveIgnorePatterns)(cfg);
+    if (fs.existsSync(localBuildScratchDir)) {
+        throw new error_1.FirebaseError(`The local build scratch directory '${localBuildScratchDir}' already exists. Please delete it and try again.`);
+    }
+    fs.mkdirSync(localBuildScratchDir, { recursive: true });
+    const filesToCopy = await fsAsync.readdirRecursive({
+        path: rootDir,
+        ignoreStrings: ignore,
+        supportGitIgnore: true,
+    });
+    for (const file of filesToCopy) {
+        const relativePath = path.relative(rootDir, file.name);
+        const destPath = path.join(localBuildScratchDir, relativePath);
+        fs.mkdirSync(path.dirname(destPath), { recursive: true });
+        fs.copyFileSync(file.name, destPath);
+    }
+}

package/lib/deploy/apphosting/release.js

@@ -19,21 +19,35 @@ async function default_1(context, options) {
         return;
     }
     const projectId = (0, projectUtils_1.needProjectId)(options);
-    const rollouts = backendIds.map((backendId) => (0, rollout_1.orchestrateRollout)({
-        projectId,
-        backendId,
-        location: context.backendLocations[backendId],
-        buildInput: {
-            config: context.backendLocalBuilds[backendId]?.buildConfig,
-            source: {
+    const rollouts = backendIds.map((backendId) => {
+        const localBuild = context.backendLocalBuilds[backendId];
+        const userStorageUri = context.backendStorageUris[backendId];
+        const rootDirectory = context.backendConfigs[backendId].rootDir;
+        const source = localBuild
+            ? {
+                locallyBuilt: {
+                    userStorageUri,
+                    rootDirectory,
+                    runCommand: localBuild.buildConfig?.runCommand,
+                    env: localBuild.buildConfig?.env,
+                },
+            }
+            : {
                 archive: {
-                    userStorageUri: context.backendStorageUris[backendId],
-                    rootDirectory: context.backendConfigs[backendId].rootDir,
-                    locallyBuiltSource: !!context.backendLocalBuilds[backendId],
+                    userStorageUri,
+                    rootDirectory,
                 },
+            };
+        return (0, rollout_1.orchestrateRollout)({
+            projectId,
+            backendId,
+            location: context.backendLocations[backendId],
+            buildInput: {
+                config: localBuild?.buildConfig,
+                source,
             },
-        },
-    }));
+        });
+    });
     (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) ${backendIds.join(", ")}; this may take a few minutes. It's safe to exit now.\n`).start();
     const results = await Promise.allSettled(rollouts);