firebase-tools 15.7.0 → 15.8.1-ct-studioexport.0

package/lib/emulator/downloadableEmulators.js

@@ -11,6 +11,7 @@ exports.stop = stop;
 exports.downloadIfNecessary = downloadIfNecessary;
 exports.start = start;
 exports.isIncomaptibleArchError = isIncomaptibleArchError;
+exports.emulatorVersionOverride = emulatorVersionOverride;
 const lsofi = require("lsofi");
 const types_1 = require("./types");
 const constants_1 = require("./constants");
@@ -41,9 +42,11 @@ function generateDownloadDetails(emulator) {
         : process.platform === "win32"
             ? EMULATOR_UPDATE_DETAILS.dataconnect.win32
             : EMULATOR_UPDATE_DETAILS.dataconnect.linux;
+    let details;
+    const overrideVersion = emulatorVersionOverride(emulator);
     switch (emulator) {
         case "database":
-            return {
+            details = {
                 downloadPath: path.join(CACHE_DIR, EMULATOR_UPDATE_DETAILS.database.downloadPathRelativeToCacheDir),
                 version: EMULATOR_UPDATE_DETAILS.database.version,
                 opts: {
@@ -52,8 +55,9 @@ function generateDownloadDetails(emulator) {
                     namePrefix: "firebase-database-emulator",
                 },
             };
+            break;
         case "firestore":
-            return {
+            details = {
                 downloadPath: path.join(CACHE_DIR, EMULATOR_UPDATE_DETAILS.firestore.downloadPathRelativeToCacheDir),
                 version: EMULATOR_UPDATE_DETAILS.firestore.version,
                 opts: {
@@ -62,8 +66,9 @@ function generateDownloadDetails(emulator) {
                     namePrefix: "cloud-firestore-emulator",
                 },
             };
+            break;
         case "storage":
-            return {
+            details = {
                 downloadPath: path.join(CACHE_DIR, EMULATOR_UPDATE_DETAILS.storage.downloadPathRelativeToCacheDir),
                 version: EMULATOR_UPDATE_DETAILS.storage.version,
                 opts: {
@@ -72,8 +77,9 @@ function generateDownloadDetails(emulator) {
                     namePrefix: "cloud-storage-rules-emulator",
                 },
             };
+            break;
         case "ui":
-            return {
+            details = {
                 version: emulatorUiDetails.version,
                 downloadPath: path.join(CACHE_DIR, emulatorUiDetails.downloadPathRelativeToCacheDir),
                 unzipDir: path.join(CACHE_DIR, `ui-v${emulatorUiDetails.version}`),
@@ -86,8 +92,9 @@ function generateDownloadDetails(emulator) {
                     namePrefix: "ui",
                 },
             };
+            break;
         case "pubsub":
-            return {
+            details = {
                 downloadPath: path.join(CACHE_DIR, EMULATOR_UPDATE_DETAILS.pubsub.downloadPathRelativeToCacheDir),
                 version: EMULATOR_UPDATE_DETAILS.pubsub.version,
                 unzipDir: path.join(CACHE_DIR, `pubsub-emulator-${EMULATOR_UPDATE_DETAILS.pubsub.version}`),
@@ -98,8 +105,9 @@ function generateDownloadDetails(emulator) {
                     namePrefix: "pubsub-emulator",
                 },
             };
+            break;
         case "dataconnect":
-            return {
+            details = {
                 downloadPath: path.join(CACHE_DIR, dataconnectDetails.downloadPathRelativeToCacheDir),
                 version: dataconnectDetails.version,
                 binaryPath: path.join(CACHE_DIR, dataconnectDetails.downloadPathRelativeToCacheDir),
@@ -111,9 +119,25 @@ function generateDownloadDetails(emulator) {
                     auth: false,
                 },
             };
+            break;
         default:
             throw new Error(`Invalid downloadable emulator: ${emulator}`);
     }
+    if (overrideVersion && overrideVersion !== details.version) {
+        const oldVersion = details.version;
+        const replaceVersion = (s) => s.split(oldVersion).join(overrideVersion);
+        details.version = overrideVersion;
+        details.downloadPath = replaceVersion(details.downloadPath);
+        if (details.unzipDir) {
+            details.unzipDir = replaceVersion(details.unzipDir);
+        }
+        if (details.binaryPath) {
+            details.binaryPath = replaceVersion(details.binaryPath);
+        }
+        details.opts.remoteUrl = replaceVersion(details.opts.remoteUrl);
+        details.opts.skipChecksumAndSize = true;
+    }
+    return details;
 }
 const EmulatorDetails = {
     database: {
@@ -437,3 +461,6 @@ function isIncomaptibleArchError(err) {
         /Unknown system error/.test(err.message ?? "") &&
         process.platform === "darwin");
 }
+function emulatorVersionOverride(emulator) {
+    return process.env[`${emulator.toUpperCase()}_EMULATOR_VERSION`];
+}

package/lib/env.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isFirebaseStudio = isFirebaseStudio;
 exports.isFirebaseMcp = isFirebaseMcp;
+exports.setFirebaseMcp = setFirebaseMcp;
 exports.detectAIAgent = detectAIAgent;
 const fsutils_1 = require("./fsutils");
 let googleIdxFolderExists;
@@ -13,8 +14,12 @@ function isFirebaseStudio() {
     googleIdxFolderExists = (0, fsutils_1.dirExistsSync)("/google/idx");
     return googleIdxFolderExists;
 }
+let isFirebaseMcpFlag = false;
 function isFirebaseMcp() {
-    return !!process.env.IS_FIREBASE_MCP;
+    return isFirebaseMcpFlag;
+}
+function setFirebaseMcp(value) {
+    isFirebaseMcpFlag = value;
 }
 function detectAIAgent() {
     if (process.env.ANTIGRAVITY_CLI_ALIAS)

package/lib/experiments.js

@@ -145,6 +145,11 @@ exports.ALL_EXPERIMENTS = experiments({
         default: false,
         public: false,
     },
+    studioexport: {
+        shortDescription: "Enable the experimental studio:export command.",
+        default: false,
+        public: false,
+    },
 });
 function isValidExperiment(name) {
     return Object.keys(exports.ALL_EXPERIMENTS).includes(name);

package/lib/firebase_studio/migrate.js

@@ -0,0 +1,391 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractMetadata = extractMetadata;
+exports.uploadSecrets = uploadSecrets;
+exports.migrate = migrate;
+const fs = require("fs/promises");
+const path = require("path");
+const child_process_1 = require("child_process");
+const logger_1 = require("../logger");
+const prompt = require("../prompt");
+const apphosting = require("../gcp/apphosting");
+const utils = require("../utils");
+const templates_1 = require("../templates");
+const secrets_1 = require("../apphosting/secrets");
+const env = require("../functions/env");
+async function downloadGitHubDir(apiUrl, localPath) {
+    const response = await fetch(apiUrl);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch directory listing: ${apiUrl}`);
+    }
+    const items = (await response.json());
+    await fs.mkdir(localPath, { recursive: true });
+    for (const item of items) {
+        const itemLocalPath = path.join(localPath, item.name);
+        if (item.type === "dir") {
+            await downloadGitHubDir(item.url, itemLocalPath);
+        }
+        else if (item.type === "file") {
+            const fileResponse = await fetch(item.download_url);
+            if (fileResponse.ok) {
+                const content = await fileResponse.arrayBuffer();
+                await fs.writeFile(itemLocalPath, Buffer.from(content));
+            }
+        }
+    }
+}
+async function extractMetadata(rootPath, overrideProjectId) {
+    const metadataPath = path.join(rootPath, "metadata.json");
+    let metadata = {};
+    try {
+        const metadataContent = await fs.readFile(metadataPath, "utf8");
+        metadata = JSON.parse(metadataContent);
+    }
+    catch (err) {
+        logger_1.logger.debug(`Could not read metadata.json at ${metadataPath}: ${err}`);
+    }
+    logger_1.logger.debug(`overrideProjectId ${overrideProjectId}`);
+    logger_1.logger.debug(`metadata.projectId ${metadata.projectId}`);
+    let projectId = overrideProjectId || metadata.projectId;
+    if (!projectId) {
+        try {
+            const firebasercContent = await fs.readFile(path.join(rootPath, ".firebaserc"), "utf8");
+            const firebaserc = JSON.parse(firebasercContent);
+            projectId = firebaserc.projects?.default;
+        }
+        catch (err) {
+            logger_1.logger.debug(`Could not read .firebaserc at ${rootPath}: ${err}`);
+        }
+    }
+    if (projectId) {
+        logger_1.logger.info(`✅ Detected Firebase Project: ${projectId}`);
+    }
+    else {
+        logger_1.logger.info(`✅ Failed to determine the Firebase Project ID`);
+    }
+    let appName = "firebase-studio-export";
+    let blueprintContent = "";
+    const blueprintPath = path.join(rootPath, "docs", "blueprint.md");
+    try {
+        blueprintContent = await fs.readFile(blueprintPath, "utf8");
+        const nameMatch = blueprintContent.match(/# \*\*App Name\*\*: (.*)/);
+        if (nameMatch && nameMatch[1]) {
+            appName = nameMatch[1].trim();
+        }
+    }
+    catch (err) {
+        logger_1.logger.debug(`Could not read blueprint.md at ${blueprintPath}: ${err}`);
+    }
+    if (appName !== "firebase-studio-export") {
+        logger_1.logger.info(`✅ Detected App Name: ${appName}`);
+    }
+    return { projectId, appName, blueprintContent };
+}
+async function updateReadme(rootPath, blueprintContent, appName) {
+    const readmePath = path.join(rootPath, "README.md");
+    const readmeTemplate = await (0, templates_1.readTemplate)("firebase-studio-export/readme_template.md");
+    const newReadme = readmeTemplate
+        .replace(/\${appName}/g, appName)
+        .replace("${exportDate}", new Date().toISOString().split("T")[0])
+        .replace("${blueprintContent}", blueprintContent.replace(/# \*\*App Name\*\*: .*/, "").trim());
+    await fs.writeFile(readmePath, newReadme);
+    logger_1.logger.info("✅ Updated README.md with project details and origin info");
+}
+async function injectAgyContext(rootPath, projectId, appName) {
+    const agentDir = path.join(rootPath, ".agent");
+    const rulesDir = path.join(agentDir, "rules");
+    const workflowsDir = path.join(agentDir, "workflows");
+    const skillsDir = path.join(agentDir, "skills");
+    await fs.mkdir(rulesDir, { recursive: true });
+    await fs.mkdir(workflowsDir, { recursive: true });
+    await fs.mkdir(skillsDir, { recursive: true });
+    logger_1.logger.info("⏳ Fetching AGY skills from firebase/agent-skills...");
+    try {
+        const skillsResponse = await fetch("https://api.github.com/repos/firebase/agent-skills/contents/skills");
+        if (!skillsResponse.ok) {
+            throw new Error(`GitHub API returned ${skillsResponse.status}`);
+        }
+        const skillsData = (await skillsResponse.json());
+        if (Array.isArray(skillsData)) {
+            for (const item of skillsData) {
+                if (item.type === "dir") {
+                    const skillName = item.name;
+                    const skillDir = path.join(skillsDir, skillName);
+                    await downloadGitHubDir(item.url, skillDir);
+                }
+            }
+        }
+        else {
+            utils.logWarning("GitHub API response for skills is not an array.");
+        }
+        logger_1.logger.info(`✅ Downloaded Firebase skills`);
+    }
+    catch (err) {
+        utils.logWarning(`Could not download AGY skills, skipping. ${err}`);
+    }
+    logger_1.logger.info("⏳ Fetching Genkit skill...");
+    try {
+        const genkitSkillDir = path.join(skillsDir, "developing-genkit-js");
+        await downloadGitHubDir("https://api.github.com/repos/genkit-ai/skills/contents/skills/developing-genkit-js?ref=main", genkitSkillDir);
+        logger_1.logger.info(`✅ Downloaded Genkit skill`);
+    }
+    catch (err) {
+        utils.logWarning(`Could not download Genkit skill, skipping. ${err}`);
+    }
+    const systemInstructionsTemplate = await (0, templates_1.readTemplate)("firebase-studio-export/system_instructions_template.md");
+    const systemInstructions = systemInstructionsTemplate
+        .replace("${projectId}", projectId || "None")
+        .replace("${appName}", appName);
+    await fs.writeFile(path.join(rulesDir, "migration-context.md"), systemInstructions);
+    logger_1.logger.info("✅ Injected AGY rules");
+    try {
+        const startupWorkflow = await (0, templates_1.readTemplate)("firebase-studio-export/workflows/startup_workflow.md");
+        await fs.writeFile(path.join(workflowsDir, "startup.md"), startupWorkflow);
+        logger_1.logger.info("✅ Created AGY startup workflow");
+    }
+    catch (err) {
+        logger_1.logger.debug(`Could not read or write startup workflow: ${err}`);
+    }
+}
+async function getAgyCommand(startAgy) {
+    if (!startAgy) {
+        return undefined;
+    }
+    const commands = ["agy", "antigravity"];
+    for (const cmd of commands) {
+        if (utils.commandExistsSync(cmd)) {
+            logger_1.logger.info(`✅ Antigravity IDE CLI (${cmd}) detected`);
+            return cmd;
+        }
+    }
+    if (process.platform === "darwin") {
+        const macPath = "/Applications/Antigravity.app/Contents/Resources/app/bin/agy";
+        try {
+            await fs.access(macPath);
+            logger_1.logger.info(`✅ Antigravity IDE CLI detected at ${macPath}`);
+            return macPath;
+        }
+        catch {
+        }
+    }
+    const downloadLink = "https://antigravity.google/download";
+    logger_1.logger.info(`⚠️ Antigravity IDE CLI (agy) not found in your PATH. To ensure a seamless migration, please download and install Antigravity: ${downloadLink}`);
+    return undefined;
+}
+async function createFirebaseConfigs(rootPath, projectId) {
+    if (!projectId) {
+        return;
+    }
+    const firebaserc = {
+        projects: {
+            default: projectId,
+        },
+    };
+    await fs.writeFile(path.join(rootPath, ".firebaserc"), JSON.stringify(firebaserc, null, 2));
+    logger_1.logger.info("✅ Created .firebaserc");
+    const firebaseJsonPath = path.join(rootPath, "firebase.json");
+    try {
+        await fs.access(firebaseJsonPath);
+        logger_1.logger.info("ℹ️ firebase.json already exists, skipping creation.");
+    }
+    catch {
+        let backendId = "studio";
+        try {
+            logger_1.logger.info(`⏳ Fetching App Hosting backends for project ${projectId}...`);
+            const backendsData = await apphosting.listBackends(projectId, "-");
+            const backends = backendsData.backends || [];
+            if (backends.length > 0) {
+                const studioBackend = backends.find((b) => b.name.endsWith("/studio") || b.name.toLowerCase().includes("studio"));
+                if (studioBackend) {
+                    backendId = studioBackend.name.split("/").pop();
+                }
+                else {
+                    backendId = backends[0].name.split("/").pop();
+                }
+                logger_1.logger.info(`✅ Selected App Hosting backend: ${backendId}`);
+            }
+            else {
+                utils.logWarning('No App Hosting backends found, using default "studio"');
+            }
+        }
+        catch (err) {
+            utils.logWarning(`Could not fetch backends from Firebase CLI, using default "studio". ${err}`);
+        }
+        const firebaseJson = {
+            apphosting: {
+                backendId: backendId,
+                ignore: [
+                    "node_modules",
+                    ".git",
+                    ".agent",
+                    ".idx",
+                    "firebase-debug.log",
+                    "firebase-debug.*.log",
+                    "functions",
+                ],
+            },
+        };
+        await fs.writeFile(firebaseJsonPath, JSON.stringify(firebaseJson, null, 2));
+        logger_1.logger.info(`✅ Created firebase.json with backendId: ${backendId}`);
+    }
+}
+async function writeAgyConfigs(rootPath) {
+    const vscodeDir = path.join(rootPath, ".vscode");
+    await fs.mkdir(vscodeDir, { recursive: true });
+    const tasksJson = {
+        version: "2.0.0",
+        tasks: [
+            {
+                label: "npm-install",
+                type: "shell",
+                command: "npm install",
+                problemMatcher: [],
+            },
+        ],
+    };
+    await fs.writeFile(path.join(vscodeDir, "tasks.json"), JSON.stringify(tasksJson, null, 2));
+    logger_1.logger.info("✅ Created .vscode/tasks.json");
+    const settingsPath = path.join(vscodeDir, "settings.json");
+    let settings = {};
+    try {
+        const settingsContent = await fs.readFile(settingsPath, "utf8");
+        settings = JSON.parse(settingsContent);
+    }
+    catch (err) {
+        logger_1.logger.debug(`Could not read ${settingsPath}: ${err}`);
+    }
+    const cleanSettings = {};
+    for (const [key, value] of Object.entries(settings)) {
+        if (!key.startsWith("IDX.")) {
+            cleanSettings[key] = value;
+        }
+    }
+    cleanSettings["workbench.startupEditor"] = "readme";
+    await fs.writeFile(settingsPath, JSON.stringify(cleanSettings, null, 2));
+    logger_1.logger.info("✅ Updated .vscode/settings.json with startup preferences");
+    const launchJson = {
+        version: "0.2.0",
+        configurations: [
+            {
+                type: "node",
+                request: "launch",
+                name: "Next.js: debug server-side",
+                runtimeExecutable: "npm",
+                runtimeArgs: ["run", "dev"],
+                port: 9002,
+                console: "integratedTerminal",
+                preLaunchTask: "npm-install",
+            },
+        ],
+    };
+    await fs.writeFile(path.join(vscodeDir, "launch.json"), JSON.stringify(launchJson, null, 2));
+    logger_1.logger.info("✅ Created .vscode/launch.json");
+}
+async function cleanupUnusedFiles(rootPath) {
+    const docsDir = path.join(rootPath, "docs");
+    const blueprintPath = path.join(docsDir, "blueprint.md");
+    try {
+        await fs.unlink(blueprintPath);
+        logger_1.logger.info("✅ Cleaned up docs/blueprint.md");
+    }
+    catch (err) {
+        logger_1.logger.debug(`Could not delete ${blueprintPath}: ${err}`);
+    }
+    try {
+        const files = await fs.readdir(docsDir);
+        if (files.length === 0) {
+            await fs.rmdir(docsDir);
+            logger_1.logger.info("✅ Removed empty docs directory");
+        }
+    }
+    catch (err) {
+        logger_1.logger.debug(`Could not remove ${docsDir}: ${err}`);
+    }
+    const metadataPath = path.join(rootPath, "metadata.json");
+    try {
+        await fs.unlink(metadataPath);
+        logger_1.logger.info("✅ Cleaned up metadata.json");
+    }
+    catch (err) {
+        logger_1.logger.debug(`Could not delete ${metadataPath}: ${err}`);
+    }
+    const modifiedPath = path.join(rootPath, ".modified");
+    try {
+        await fs.unlink(modifiedPath);
+        logger_1.logger.info("✅ Cleaned up .modified");
+    }
+    catch (err) {
+        logger_1.logger.debug(`Could not delete ${modifiedPath}: ${err}`);
+    }
+}
+async function uploadSecrets(rootPath, projectId) {
+    if (!projectId) {
+        return;
+    }
+    const envPath = path.join(rootPath, ".env");
+    try {
+        await fs.access(envPath);
+    }
+    catch {
+        return;
+    }
+    try {
+        const envContent = await fs.readFile(envPath, "utf8");
+        const parsedEnv = env.parse(envContent);
+        const geminiApiKey = parsedEnv.envs["GEMINI_API_KEY"];
+        if (geminiApiKey && geminiApiKey.trim().length > 0) {
+            logger_1.logger.info("⏳ Uploading GEMINI_API_KEY from .env to App Hosting secrets...");
+            await (0, secrets_1.apphostingSecretsSetAction)("GEMINI_API_KEY", projectId, undefined, undefined, envPath, true);
+            logger_1.logger.info("✅ Uploaded GEMINI_API_KEY secret");
+        }
+        else {
+            logger_1.logger.debug("Skipping GEMINI_API_KEY upload: key is missing or blank in .env");
+        }
+    }
+    catch (err) {
+        utils.logWarning(`Failed to upload GEMINI_API_KEY secret: ${err}`);
+    }
+}
+async function askToOpenAntigravity(rootPath, appName, startAgy) {
+    const agyCommand = await getAgyCommand(startAgy);
+    if (!startAgy || !agyCommand) {
+        logger_1.logger.info('\n👉 Next steps: Open this folder in Antigravity and run the "Initial Project Setup" workflow.');
+        return;
+    }
+    const answer = await prompt.confirm({
+        message: `Migration complete for ${appName}! Would you like to open it in Antigravity now?`,
+        default: true,
+    });
+    if (answer) {
+        logger_1.logger.info(`⏳ Opening ${appName} in Antigravity...`);
+        try {
+            const agyProcess = (0, child_process_1.spawn)(agyCommand, ["."], {
+                cwd: rootPath,
+                stdio: "ignore",
+                detached: true,
+            });
+            agyProcess.unref();
+        }
+        catch (err) {
+            utils.logWarning("Could not open Antigravity IDE automatically. Please open it manually.");
+        }
+    }
+    else {
+        logger_1.logger.info('\n👉 Next steps: Open this folder in Antigravity and run the "Initial Project Setup" workflow.');
+    }
+}
+async function migrate(rootPath, options = { startAgy: true }) {
+    logger_1.logger.info("🚀 Starting Firebase Studio to Antigravity migration...");
+    const { projectId, appName, blueprintContent } = await extractMetadata(rootPath, options.project);
+    await updateReadme(rootPath, blueprintContent, appName);
+    await createFirebaseConfigs(rootPath, projectId);
+    await uploadSecrets(rootPath, projectId);
+    await injectAgyContext(rootPath, projectId, appName);
+    await writeAgyConfigs(rootPath);
+    await cleanupUnusedFiles(rootPath);
+    const currentFolderName = path.basename(rootPath);
+    if (currentFolderName === "download") {
+        logger_1.logger.info(`\n💡 Tip: You might want to rename this folder to "${appName.toLowerCase().replace(/\s+/g, "-")}"`);
+    }
+    await askToOpenAntigravity(rootPath, appName, options.startAgy);
+}

package/lib/functionsConfig.js

@@ -27,11 +27,11 @@ const utils_1 = require("./utils");
 exports.RESERVED_NAMESPACES = ["firebase"];
 const apiClient = new apiv2_1.Client({ urlPrefix: (0, api_1.firebaseApiOrigin)() });
 const LEGACY_RUNTIME_CONFIG_EXPERIMENT = "legacyRuntimeConfigCommands";
-const FUNCTIONS_CONFIG_DEPRECATION_MESSAGE = `DEPRECATION NOTICE: Action required before March 2026
+const FUNCTIONS_CONFIG_DEPRECATION_MESSAGE = `DEPRECATION NOTICE: Action required before March 2027
 
-The functions.config() API and the Cloud Runtime Config service are deprecated. Deploys that rely on functions.config() will fail once Runtime Config shuts down in March 2026.
+The functions.config() API and the Cloud Runtime Config service are deprecated. Deploys that rely on functions.config() will fail once Runtime Config shuts down in March 2027.
 
-The legacy functions:config:* CLI commands are deprecated and will be removed before March 2026.
+The legacy functions:config:* CLI commands are deprecated and will be removed before March 2027.
 
 Learn how to migrate from functions.config() to the params package:
 

package/lib/gcp/cloudsql/cloudsqladmin.js

@@ -23,6 +23,7 @@ const projectUtils_1 = require("../../projectUtils");
 const logger_1 = require("../../logger");
 const iam_1 = require("../iam");
 const error_1 = require("../../error");
+const freeTrial_1 = require("../../dataconnect/freeTrial");
 const API_VERSION = "v1";
 const client = new apiv2_1.Client({
     urlPrefix: (0, api_1.cloudSQLAdminOrigin)(),
@@ -91,7 +92,7 @@ async function createInstance(args) {
         return;
     }
     catch (err) {
-        handleAllowlistError(err, args.location);
+        await handleCreateInstanceError(err, args.location, args.projectId);
         throw err;
     }
 }
@@ -119,10 +120,14 @@ async function updateInstanceForDataConnect(instance, enableGoogleMlIntegration)
     });
     return pollRes;
 }
-function handleAllowlistError(err, region) {
-    if (err.message.includes("Not allowed to set system label: firebase-data-connect")) {
+async function handleCreateInstanceError(err, region, projectId) {
+    if (err?.message?.includes("Not allowed to set system label: firebase-data-connect")) {
         throw new error_1.FirebaseError(`Cloud SQL free trial instances are not yet available in ${region}. Please check https://firebase.google.com/docs/data-connect/ for a full list of available regions.`);
     }
+    if (err?.message?.includes("The billing account is not in good standing") &&
+        (await (0, freeTrial_1.checkFreeTrialInstanceUsed)(projectId))) {
+        throw new error_1.FirebaseError(`You have already used your Cloud SQL free trial. To create more instances, you need to attach a billing account to project ${projectId}.`);
+    }
 }
 function setDatabaseFlag(flag, flags = []) {
     const temp = flags.filter((f) => f.name !== flag.name);

package/lib/gcp/cloudsql/fbToolsAuthClient.js

@@ -36,7 +36,7 @@ class FBToolsAuthClient extends google_auth_library_1.AuthClient {
     async getRequestHeaders() {
         const token = await this.getAccessToken();
         return {
-            ...apiv2.STANDARD_HEADERS,
+            ...apiv2.standardHeaders(),
             Authorization: `Bearer ${token.token}`,
         };
     }

package/lib/gcp/runv2.js

@@ -42,7 +42,7 @@ async function submitBuild(projectId, location, build) {
 async function updateService(service) {
     const fieldMask = proto.fieldMasks(service, "labels", "annotations", "tags");
     fieldMask.push("template.revision");
-    const res = await client.post(service.name, service, {
+    const res = await client.patch(service.name, service, {
         queryParams: {
             updateMask: fieldMask.join(","),
         },
@@ -155,7 +155,8 @@ function endpointFromService(service) {
             : service.annotations?.["run.googleapis.com/ingress"] === "internal-and-cloud-load-balancing"
                 ? "ALLOW_INTERNAL_AND_GCLB"
                 : "ALLOW_ALL"),
-        ...(service.annotations?.[exports.TRIGGER_TYPE_ANNOTATION] === "HTTP_TRIGGER"
+        ...(!service.annotations?.[exports.TRIGGER_TYPE_ANNOTATION] ||
+            service.annotations?.[exports.TRIGGER_TYPE_ANNOTATION] === "HTTP_TRIGGER"
             ? { httpsTrigger: {} }
             : {
                 eventTrigger: {

package/lib/mcp/onemcp/index.js

@@ -4,5 +4,11 @@ exports.ONEMCP_SERVERS = void 0;
 const api_1 = require("../../api");
 const onemcp_server_1 = require("./onemcp_server");
 exports.ONEMCP_SERVERS = {
-    developerknowledge: new onemcp_server_1.OneMcpServer("developerknowledge", (0, api_1.developerKnowledgeOrigin)()),
+    developerknowledge: new onemcp_server_1.OneMcpServer("developerknowledge", (0, api_1.developerKnowledgeOrigin)(), {
+        requiresAuth: true,
+    }),
+    firestore: new onemcp_server_1.OneMcpServer("firestore", (0, api_1.firestoreOrigin)(), {
+        requiresAuth: true,
+        requiresProject: true,
+    }),
 };

package/lib/mcp/onemcp/onemcp_server.js

@@ -6,9 +6,10 @@ const apiv2_1 = require("../../apiv2");
 const error_1 = require("../../error");
 const ensureApiEnabled_1 = require("../../ensureApiEnabled");
 class OneMcpServer {
-    constructor(feature, serverUrl) {
+    constructor(feature, serverUrl, meta) {
         this.feature = feature;
         this.serverUrl = serverUrl;
+        this.meta = meta;
         this.listClient = new apiv2_1.Client({
             urlPrefix: this.serverUrl,
             auth: false,
@@ -30,9 +31,7 @@ class OneMcpServer {
                 mcp: {
                     ...mcpTool,
                     name: `${this.feature}_${mcpTool.name}`,
-                    _meta: {
-                        requiresAuth: true,
-                    },
+                    _meta: { ...this.meta, feature: this.feature },
                 },
                 fn: (args, ctx) => this.callTool(mcpTool.name, args, ctx),
                 isAvailable: () => Promise.resolve(true),