firebase-tools 15.17.0 → 15.18.0

package/lib/apphosting/localbuilds.js

@@ -1,10 +1,121 @@
 "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");
+const logger_1 = require("../logger");
+const utils_1 = require("../utils");
+const universalMakerDownload_1 = require("./universalMakerDownload");
+async function runUniversalMaker(projectRoot, framework) {
+    const universalMakerBinary = await (0, universalMakerDownload_1.getOrDownloadUniversalMaker)();
+    executeUniversalMakerBinary(universalMakerBinary, projectRoot);
+    return processUniversalMakerOutput(projectRoot, framework);
+}
+function executeUniversalMakerBinary(universalMakerBinary, projectRoot) {
+    try {
+        const bundleOutput = path.join(projectRoot, "bundle_output");
+        fs.removeSync(bundleOutput);
+        fs.ensureDirSync(bundleOutput);
+        const res = childProcess.spawnSync(universalMakerBinary, ["-application_dir", projectRoot, "-output_dir", projectRoot, "-output_format", "json"], {
+            env: {
+                ...process.env,
+                X_GOOGLE_TARGET_PLATFORM: "fah",
+                FIREBASE_OUTPUT_BUNDLE_DIR: bundleOutput,
+            },
+            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;
+    if (!outputFiles) {
+        throw new error_1.FirebaseError("Failed to resolve build artifacts. Ensure Universal Maker produced a valid bundle.yaml with outputFiles.");
+    }
+    return { runCommand, outputFiles };
+}
+function processUniversalMakerOutput(projectRoot, framework) {
+    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);
+    const bundleOutput = path.join(projectRoot, "bundle_output");
+    const targetAppHosting = path.join(projectRoot, ".apphosting");
+    if (fs.existsSync(bundleOutput)) {
+        fs.ensureDirSync(targetAppHosting);
+        const files = fs.readdirSync(bundleOutput);
+        for (const file of files) {
+            const dest = path.join(targetAppHosting, file);
+            if (fs.existsSync(dest)) {
+                fs.removeSync(dest);
+            }
+            fs.moveSync(path.join(bundleOutput, file), dest);
+        }
+        fs.removeSync(bundleOutput);
+    }
+    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 {
+        metadata: {
+            language: umOutput.language,
+            runtime: umOutput.runtime,
+            framework: framework || "nextjs",
+        },
+        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, framework, env = {}, options) {
     const hasBuildAvailableSecrets = Object.values(env).some((v) => v.secret && (!v.availability || v.availability.includes("BUILD")));
     if (hasBuildAvailableSecrets && !options?.allowLocalBuildSecrets) {
@@ -25,7 +136,7 @@ async function localBuild(projectId, projectRoot, framework, env = {}, options)
     }
     let apphostingBuildOutput;
     try {
-        apphostingBuildOutput = await (0, build_1.localBuild)(projectRoot, framework);
+        apphostingBuildOutput = await runUniversalMaker(projectRoot, framework);
     }
     finally {
         for (const key in process.env) {
@@ -41,7 +152,7 @@ async function localBuild(projectId, projectRoot, framework, env = {}, options)
     const discoveredEnv = apphostingBuildOutput.runConfig.environmentVariables?.map(({ variable, value, availability }) => ({
         variable,
         value,
-        availability,
+        availability: availability,
     }));
     return {
         outputFiles: apphostingBuildOutput.outputFiles?.serverApp.include ?? [],
@@ -58,7 +169,7 @@ async function toProcessEnv(projectId, env) {
             return null;
         }
         if (value.secret) {
-            const resolvedValue = await (0, secrets_1.loadSecret)(projectId, value.secret);
+            const resolvedValue = await (0, index_1.loadSecret)(projectId, value.secret);
             return [key, resolvedValue];
         }
         else {

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": 16111618,
+        "expectedChecksumSHA256": "4b77d02a5f80f26d9bd1428f388c293c1fb264995d75b51c7d50fec7c87bcf58",
+        "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": 16856277,
+        "expectedChecksumSHA256": "dfc8357b8ce23ef1897e5590d4390f166e27734f241b770f721d68273118845c",
+        "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/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);

package/lib/deploy/apphosting/util.js

@@ -16,8 +16,8 @@ async function createLocalBuildTarArchive(config, rootDir, targetSubDir) {
     const ignore = ["firebase-debug.log", "firebase-debug.*.log", ".git"];
     const rdrFiles = await fsAsync.readdirRecursive({
         path: targetDir,
-        ignore: ignore,
-        isGitIgnore: true,
+        ignoreStrings: ignore,
+        supportGitIgnore: true,
     });
     const allFiles = rdrFiles.map((rdrf) => path.relative(rootDir, rdrf.name));
     if (targetSubDir) {
@@ -60,13 +60,11 @@ async function createSourceDeployArchive(config, rootDir, targetSubDir) {
     const targetDir = targetSubDir ? path.join(rootDir, targetSubDir) : rootDir;
     const ignore = config.ignore || ["node_modules", ".git"];
     ignore.push("firebase-debug.log", "firebase-debug.*.log");
-    const gitIgnorePatterns = parseGitIgnorePatterns(targetDir);
-    ignore.push(...gitIgnorePatterns);
     try {
         const files = await fsAsync.readdirRecursive({
             path: targetDir,
-            ignore: ignore,
-            isGitIgnore: true,
+            ignoreStrings: ignore,
+            supportGitIgnore: true,
         });
         for (const file of files) {
             const name = path.relative(rootDir, file.name);
@@ -82,19 +80,6 @@ async function createSourceDeployArchive(config, rootDir, targetSubDir) {
     }
     return tmpFile;
 }
-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();

package/lib/deploy/functions/backend.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.missingEndpoint = exports.hasEndpoint = exports.AllFunctionsPlatforms = exports.SCHEDULED_FUNCTION_LABEL = exports.MIN_CPU_FOR_CONCURRENCY = exports.DEFAULT_MEMORY = exports.DEFAULT_CONCURRENCY = exports.AllIngressSettings = exports.AllVpcEgressSettings = void 0;
+exports.missingEndpoint = exports.hasEndpoint = exports.AllFunctionsPlatforms = exports.SCHEDULED_FUNCTION_LABEL = exports.MIN_CPU_FOR_CONCURRENCY = exports.DEFAULT_TIMEOUT_SECONDS = exports.DEFAULT_MEMORY = exports.DEFAULT_CONCURRENCY = exports.AllIngressSettings = exports.AllVpcEgressSettings = void 0;
 exports.endpointTriggerType = endpointTriggerType;
 exports.isValidMemoryOption = isValidMemoryOption;
 exports.isValidEgressSetting = isValidEgressSetting;
@@ -116,6 +116,7 @@ function memoryToGen2Cpu(memory) {
 }
 exports.DEFAULT_CONCURRENCY = 80;
 exports.DEFAULT_MEMORY = 256;
+exports.DEFAULT_TIMEOUT_SECONDS = 60;
 exports.MIN_CPU_FOR_CONCURRENCY = 1;
 exports.SCHEDULED_FUNCTION_LABEL = Object.freeze({ deployment: "firebase-schedule" });
 function secretVersionName(s) {

package/lib/deploy/functions/prepare.js

@@ -2,12 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_FUNCTION_REGION = exports.EVENTARC_SOURCE_ENV = void 0;
 exports.prepare = prepare;
-exports.matchRegionsForExisting = matchRegionsForExisting;
-exports.resolveDefaultRegions = resolveDefaultRegions;
+exports.resolveDefaultRegionsForBuild = resolveDefaultRegionsForBuild;
 exports.inferDetailsFromExisting = inferDetailsFromExisting;
 exports.updateEndpointTargetedStatus = updateEndpointTargetedStatus;
 exports.inferBlockingDetails = inferBlockingDetails;
 exports.resolveCpuAndConcurrency = resolveCpuAndConcurrency;
+exports.resolveDefaultTimeout = resolveDefaultTimeout;
 exports.loadCodebases = loadCodebases;
 exports.warnIfNewGenkitFunctionIsMissingSecrets = warnIfNewGenkitFunctionIsMissingSecrets;
 exports.ensureAllRequiredAPIsEnabled = ensureAllRequiredAPIsEnabled;
@@ -78,6 +78,7 @@ async function prepare(context, options, payload) {
     }
     context.hasRuntimeConfig = Object.keys(runtimeConfig).some((k) => k !== "firebase");
     const wantBuilds = await loadCodebases(context.config, options, firebaseConfig, runtimeConfig, context.filters);
+    const existingBackend = await backend.existingBackend(context);
     if (Object.values(wantBuilds).some((b) => b.extensions)) {
         const extContext = {};
         const extPayload = {};
@@ -99,6 +100,10 @@ async function prepare(context, options, payload) {
         proto.convertIfPresent(userEnvOpt, localCfg, "configDir", (cd) => options.config.path(cd));
         const userEnvs = functionsEnv.loadUserEnvs(userEnvOpt);
         const envs = { ...userEnvs, ...firebaseEnvs };
+        const relevantEndpoints = backend
+            .allEndpoints(existingBackend)
+            .filter((e) => e.codebase === codebase || e.codebase === undefined);
+        await resolveDefaultRegionsForBuild(wantBuild, backend.of(...relevantEndpoints));
         const { backend: wantBackend, envs: resolvedEnvs } = await build.resolveBackend({
             build: wantBuild,
             firebaseConfig,
@@ -194,13 +199,6 @@ async function prepare(context, options, payload) {
         context.sources[codebase] = source;
     }
     payload.functions = {};
-    const existingBackend = await backend.existingBackend(context);
-    for (const [codebase, wantBackend] of Object.entries(wantBackends)) {
-        const relevantEndpoints = backend
-            .allEndpoints(existingBackend)
-            .filter((e) => e.codebase === codebase || e.codebase === undefined);
-        await resolveDefaultRegions(wantBackend, backend.of(...relevantEndpoints));
-    }
     const haveBackends = (0, functionsDeployHelper_1.groupEndpointsByCodebase)(wantBackends, backend.allEndpoints(existingBackend));
     for (const [codebase, wantBackend] of Object.entries(wantBackends)) {
         const haveBackend = haveBackends[codebase] || backend.empty();
@@ -210,6 +208,7 @@ async function prepare(context, options, payload) {
         inferDetailsFromExisting(wantBackend, haveBackend, codebaseUsesEnvs.includes(codebase));
         await (0, triggerRegionHelper_1.ensureTriggerRegions)(wantBackend);
         resolveCpuAndConcurrency(wantBackend);
+        resolveDefaultTimeout(wantBackend);
         validate.endpointsAreValid(wantBackend);
         inferBlockingDetails(wantBackend);
     }
@@ -232,52 +231,38 @@ async function prepare(context, options, payload) {
     validate.checkFiltersIntegrity(wantBackends, context.filters);
     (0, applyHash_1.applyBackendHashToBackends)(wantBackends, context);
 }
-function moveEndpointToRegion(backend, endpoint, region) {
-    endpoint.region = region;
-    backend.endpoints[region] = backend.endpoints[region] || {};
-    backend.endpoints[region][endpoint.id] = endpoint;
-    delete backend.endpoints[build.REGION_TBD][endpoint.id];
-    if (Object.keys(backend.endpoints[build.REGION_TBD]).length === 0) {
-        delete backend.endpoints[build.REGION_TBD];
-    }
-}
-function matchRegionsForExisting(want, have) {
-    for (const [id, wantE] of Object.entries(want.endpoints[build.REGION_TBD] || {})) {
-        let matching;
-        for (const region of Object.keys(have.endpoints)) {
-            if (region === build.REGION_TBD) {
-                continue;
-            }
-            if (have.endpoints[region][id]) {
-                if (matching) {
-                    throw new error_1.FirebaseError(`Cannot resolve default region for function ${id}. It exists in multiple regions. The region must be specified to continue.`);
+async function resolveDefaultRegionsForBuild(buildObj, have) {
+    for (const [id, endpoint] of Object.entries(buildObj.endpoints)) {
+        if (!endpoint.region?.length || endpoint.region.includes(build.REGION_TBD)) {
+            let resolvedRegion = exports.DEFAULT_FUNCTION_REGION;
+            let matching;
+            for (const region of Object.keys(have.endpoints)) {
+                if (have.endpoints[region][id]) {
+                    if (matching) {
+                        throw new error_1.FirebaseError(`Cannot resolve default region for function ${id}. It exists in multiple regions. The region must be specified to continue.`);
+                    }
+                    matching = have.endpoints[region][id];
                 }
-                matching = have.endpoints[region][id];
             }
-        }
-        if (!matching) {
-            continue;
-        }
-        moveEndpointToRegion(want, wantE, matching.region);
-    }
-}
-async function resolveDefaultRegions(want, have) {
-    matchRegionsForExisting(want, have);
-    const endpoints = Object.values(want.endpoints[build.REGION_TBD] || {});
-    for (const endpoint of endpoints) {
-        let resolvedRegion = "us-central1";
-        try {
-            if (backend.isBlockingTriggered(endpoint)) {
-                resolvedRegion = resolveRegionForBlockingTrigger(endpoint);
+            if (matching) {
+                resolvedRegion = matching.region;
             }
-            else if (backend.isEventTriggered(endpoint)) {
-                resolvedRegion = await resolveRegionForEventTrigger(endpoint);
+            else {
+                try {
+                    const fullEndpoint = { ...endpoint, id };
+                    if (build.isBlockingTriggered(endpoint)) {
+                        resolvedRegion = resolveRegionForBlockingTrigger(fullEndpoint);
+                    }
+                    else if (build.isEventTriggered(endpoint)) {
+                        resolvedRegion = await resolveRegionForEventTrigger(fullEndpoint);
+                    }
+                }
+                catch (err) {
+                    logger_1.logger.debug(`Failed to resolve region for endpoint ${id}. Defaulting to ${exports.DEFAULT_FUNCTION_REGION}.`, (0, error_1.getErrStack)(err));
+                }
             }
+            endpoint.region = [resolvedRegion];
         }
-        catch (err) {
-            logger_1.logger.debug(`Failed to resolve region for endpoint ${endpoint.id}. Defaulting to us-central1.`, (0, error_1.getErrStack)(err));
-        }
-        moveEndpointToRegion(want, endpoint, resolvedRegion);
     }
 }
 function resolveRegionForBlockingTrigger(endpoint) {
@@ -389,6 +374,9 @@ function inferDetailsFromExisting(want, have, usedDotenv) {
         if (typeof wantE.cpu === "undefined" && haveE.cpu) {
             wantE.cpu = haveE.cpu;
         }
+        if (typeof wantE.timeoutSeconds === "undefined" && haveE.timeoutSeconds) {
+            wantE.timeoutSeconds = haveE.timeoutSeconds;
+        }
         wantE.securityLevel = haveE.securityLevel ? haveE.securityLevel : "SECURE_ALWAYS";
         maybeCopyTriggerRegion(wantE, haveE);
     }
@@ -454,6 +442,13 @@ function resolveCpuAndConcurrency(want) {
         }
     }
 }
+function resolveDefaultTimeout(want) {
+    for (const e of backend.allEndpoints(want)) {
+        if (e.platform === "run" && e.timeoutSeconds === undefined) {
+            e.timeoutSeconds = backend.DEFAULT_TIMEOUT_SECONDS;
+        }
+    }
+}
 async function loadCodebases(config, options, firebaseConfig, runtimeConfig, filters) {
     const codebases = (0, functionsDeployHelper_1.targetCodebases)(config, filters);
     const projectId = (0, projectUtils_1.needProjectId)(options);

package/lib/deploy/functions/prepareFunctionsUpload.js

@@ -78,7 +78,7 @@ async function packageSource(projectDir, sourceDir, config, additionalSources, r
     const ignore = config.ignore || ["node_modules", ".git"];
     ignore.push("firebase-debug.log", "firebase-debug.*.log", CONFIG_DEST_FILE);
     try {
-        const files = await fsAsync.readdirRecursive({ path: sourceDir, ignore: ignore });
+        const files = await fsAsync.readdirRecursive({ path: sourceDir, ignoreStrings: ignore });
         hashes.push(...(await addFilesToArchive(archive, files, sourceDir, options?.executablePaths)));
         for (const name of additionalSources) {
             const absPath = utils.resolveWithin(projectDir, name);

package/lib/deploy/functions/services/ailogic.js

@@ -32,6 +32,16 @@ class AILogicService {
         this.name = "ailogic";
         this.api = "firebasevertexai.googleapis.com";
     }
+    async requiredProjectBindings(projectNumber) {
+        return [
+            {
+                role: "roles/run.invoker",
+                members: [
+                    `serviceAccount:service-${projectNumber}@gcp-sa-firebasevertexai.iam.gserviceaccount.com`,
+                ],
+            },
+        ];
+    }
     validateTrigger(endpoint, wantBackend) {
         if (!isAILogicEvent(endpoint)) {
             return;

package/lib/deploy/functions/validate.js

@@ -221,7 +221,7 @@ async function secretsAreValid(projectId, wantBackend) {
     validatePlatformTargets(endpoints);
     await validateSecretVersions(projectId, endpoints);
 }
-const secretsSupportedPlatforms = ["gcfv1", "gcfv2"];
+const secretsSupportedPlatforms = backend.AllFunctionsPlatforms;
 function validatePlatformTargets(endpoints) {
     const unsupported = endpoints.filter((e) => !secretsSupportedPlatforms.includes(e.platform));
     if (unsupported.length > 0) {

package/lib/downloadUtils.js

@@ -1,7 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.downloadToTmp = downloadToTmp;
+exports.validateSize = validateSize;
+exports.validateChecksum = validateChecksum;
 const url_1 = require("url");
+const crypto = require("crypto");
 const fs = require("fs-extra");
 const ProgressBar = require("progress");
 const tmp = require("tmp");
@@ -37,3 +40,24 @@ async function downloadToTmp(remoteUrl, auth = false) {
     });
     return tmpfile.name;
 }
+function validateSize(filepath, expectedSize) {
+    return new Promise((resolve, reject) => {
+        const stat = fs.statSync(filepath);
+        return stat.size === expectedSize
+            ? resolve()
+            : reject(new error_1.FirebaseError(`download failed, expected ${expectedSize} bytes but got ${stat.size}`, { exit: 1 }));
+    });
+}
+function validateChecksum(filepath, expectedChecksum, algorithm = "md5") {
+    return new Promise((resolve, reject) => {
+        const hash = crypto.createHash(algorithm);
+        const stream = fs.createReadStream(filepath);
+        stream.on("data", (data) => hash.update(data));
+        stream.on("end", () => {
+            const checksum = hash.digest("hex");
+            return checksum === expectedChecksum
+                ? resolve()
+                : reject(new error_1.FirebaseError(`download failed, expected checksum ${expectedChecksum} but got ${checksum}`, { exit: 1 }));
+        });
+    });
+}

package/lib/emulator/download.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.downloadEmulator = downloadEmulator;
 exports.downloadExtensionVersion = downloadExtensionVersion;
-const crypto = require("crypto");
 const fs = require("fs-extra");
 const path = require("path");
 const tmp = require("tmp");
@@ -36,8 +35,8 @@ async function downloadEmulator(name) {
         throw err;
     }
     if (!emulator.opts.skipChecksumAndSize) {
-        await validateSize(tmpfile, emulator.opts.expectedSize);
-        await validateChecksum(tmpfile, emulator.opts.expectedChecksum);
+        await downloadUtils.validateSize(tmpfile, emulator.opts.expectedSize);
+        await downloadUtils.validateChecksum(tmpfile, emulator.opts.expectedChecksum, "md5");
     }
     if (emulator.opts.skipCache) {
         removeOldFiles(name, emulator, true);
@@ -82,24 +81,3 @@ function removeOldFiles(name, emulator, removeAllVersions = false) {
         }
     }
 }
-function validateSize(filepath, expectedSize) {
-    return new Promise((resolve, reject) => {
-        const stat = fs.statSync(filepath);
-        return stat.size === expectedSize
-            ? resolve()
-            : reject(new error_1.FirebaseError(`download failed, expected ${expectedSize} bytes but got ${stat.size}`, { exit: 1 }));
-    });
-}
-function validateChecksum(filepath, expectedChecksum) {
-    return new Promise((resolve, reject) => {
-        const hash = crypto.createHash("md5");
-        const stream = fs.createReadStream(filepath);
-        stream.on("data", (data) => hash.update(data));
-        stream.on("end", () => {
-            const checksum = hash.digest("hex");
-            return checksum === expectedChecksum
-                ? resolve()
-                : reject(new error_1.FirebaseError(`download failed, expected checksum ${expectedChecksum} but got ${checksum}`, { exit: 1 }));
-        });
-    });
-}