firebase-tools 15.10.0 → 15.11.0

package/lib/firebase_studio/migrate.js

@@ -6,6 +6,7 @@ exports.migrate = migrate;
 const fs = require("fs/promises");
 const path = require("path");
 const child_process_1 = require("child_process");
+const semver = require("semver");
 const logger_1 = require("../logger");
 const prompt = require("../prompt");
 const apphosting = require("../gcp/apphosting");
@@ -16,7 +17,7 @@ const secrets_1 = require("../apphosting/secrets");
 const env = require("../functions/env");
 const error_1 = require("../error");
 const os = require("os");
-async function setupAntigravityMcpServer(rootPath) {
+async function setupAntigravityMcpServer(rootPath, appType) {
     const mcpConfigDir = path.join(os.homedir(), ".gemini", "antigravity");
     const mcpConfigPath = path.join(mcpConfigDir, "mcp_config.json");
     let mcpConfig = { mcpServers: {} };
@@ -36,16 +37,56 @@ async function setupAntigravityMcpServer(rootPath) {
                 mcpConfig.mcpServers = {};
             }
         }
-        if (mcpConfig.mcpServers["firebase"]) {
+        let updated = false;
+        if (!mcpConfig.mcpServers["firebase"]) {
+            if (utils.commandExistsSync("npx")) {
+                const confirmFirebase = await prompt.confirm({
+                    message: "Would you like to enable the Firebase MCP server for Antigravity?",
+                    default: true,
+                });
+                if (confirmFirebase) {
+                    mcpConfig.mcpServers["firebase"] = {
+                        command: "npx",
+                        args: ["-y", "firebase-tools@latest", "mcp", "--dir", path.resolve(rootPath)],
+                    };
+                    updated = true;
+                    logger_1.logger.info(`✅ Configured Firebase MCP server in ${mcpConfigPath}`);
+                }
+            }
+            else {
+                logger_1.logger.info("ℹ️ npx not found on PATH, skipping Firebase MCP server configuration.");
+            }
+        }
+        else {
             logger_1.logger.info("ℹ️ Firebase MCP server already configured in Antigravity, skipping.");
-            return;
         }
-        mcpConfig.mcpServers["firebase"] = {
-            command: "npx",
-            args: ["-y", "firebase-tools@latest", "mcp", "--dir", path.resolve(rootPath)],
-        };
-        await fs.writeFile(mcpConfigPath, JSON.stringify(mcpConfig, null, 2));
-        logger_1.logger.info(`✅ Configured Firebase MCP server in ${mcpConfigPath}`);
+        if (appType === "FLUTTER") {
+            if (utils.commandExistsSync("dart")) {
+                if (!mcpConfig.mcpServers["dart"]) {
+                    const confirmDart = await prompt.confirm({
+                        message: "Would you like to enable the Dart MCP server for Antigravity?",
+                        default: true,
+                    });
+                    if (confirmDart) {
+                        mcpConfig.mcpServers["dart"] = {
+                            command: "dart",
+                            args: ["mcp-server"],
+                        };
+                        updated = true;
+                        logger_1.logger.info(`✅ Configured Dart MCP server in ${mcpConfigPath}`);
+                    }
+                }
+                else {
+                    logger_1.logger.info("ℹ️ Dart MCP server already configured in Antigravity, skipping.");
+                }
+            }
+            else {
+                utils.logWarning("Couldn't find Dart/Flutter on PATH. Install Flutter by following the instruction at https://docs.flutter.dev/install.");
+            }
+        }
+        if (updated) {
+            await fs.writeFile(mcpConfigPath, JSON.stringify(mcpConfig, null, 2));
+        }
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
@@ -89,40 +130,23 @@ async function detectAppType(rootPath) {
     }
     return "OTHER";
 }
-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));
-            }
-        }
-    }
-}
 const isValidFirebaseProjectId = (projectId) => {
     const projectIdRegex = /^[a-z][a-z0-9-]{4,28}[a-z0-9]$/;
     return projectIdRegex.test(projectId);
 };
 async function extractMetadata(rootPath, overrideProjectId) {
+    const studioJsonPath = path.join(rootPath, "studio.json");
     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}`);
+    for (const metadataFile of [metadataPath, studioJsonPath]) {
+        try {
+            const metadataContent = await fs.readFile(metadataFile, "utf8");
+            metadata = JSON.parse(metadataContent);
+            logger_1.logger.info(`✅ Read ${metadataFile}`);
+        }
+        catch (err) {
+            logger_1.logger.debug(`Could not read metadata at ${metadataFile}: ${err}`);
+        }
     }
     logger_1.logger.debug(`overrideProjectId ${overrideProjectId}`);
     logger_1.logger.debug(`metadata.projectId ${metadata.projectId}`);
@@ -146,14 +170,13 @@ async function extractMetadata(rootPath, overrideProjectId) {
         logger_1.logger.info(`✅ Using Firebase Project: ${projectId}`);
     }
     else {
-        logger_1.logger.info(`❌ Failed to determine the Firebase Project ID. You can set a project later with 'firebase use <project-id>' or by setting the '--project' flag.`);
+        logger_1.logger.debug(`❌ Failed to determine the Firebase Project ID. You can set a project later by setting the '--project' flag.`);
     }
     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\*\*: (.*)/);
+        const content = await fs.readFile(blueprintPath, "utf8");
+        const nameMatch = content.match(/# \*\*App Name\*\*: (.*)/);
         if (nameMatch && nameMatch[1]) {
             appName = nameMatch[1].trim();
         }
@@ -164,15 +187,34 @@ async function extractMetadata(rootPath, overrideProjectId) {
     if (appName !== "firebase-studio-export") {
         logger_1.logger.info(`✅ Detected App Name: ${appName}`);
     }
-    return { projectId, appName, blueprintContent };
+    return { projectId, appName };
 }
-async function updateReadme(rootPath, blueprintContent, appName) {
+async function updateReadme(rootPath, framework) {
     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)
+    const frameworkConfigs = {
+        NEXT_JS: { startCommand: "npm run dev", localUrl: "http://localhost:9002" },
+        ANGULAR: { startCommand: "npm run start", localUrl: "http://localhost:4200" },
+        FLUTTER: {
+            startCommand: "flutter run -d chrome --web-port=8080",
+            localUrl: "http://localhost:8080",
+        },
+        OTHER: { startCommand: "npm run dev", localUrl: "http://localhost:9002" },
+    };
+    const { startCommand, localUrl } = frameworkConfigs[framework];
+    let existingReadme = "";
+    try {
+        existingReadme = await fs.readFile(readmePath, "utf8");
+    }
+    catch (err) {
+    }
+    let newReadme = readmeTemplate
         .replace("${exportDate}", new Date().toISOString().split("T")[0])
-        .replace("${blueprintContent}", blueprintContent.replace(/# \*\*App Name\*\*: .*/, "").trim());
+        .replace("${startCommand}", startCommand)
+        .replace("${localUrl}", localUrl);
+    if (existingReadme.trim()) {
+        newReadme += `\n\n---\n\n## Previous README.md contents:\n\n${existingReadme}`;
+    }
     await fs.writeFile(readmePath, newReadme);
     logger_1.logger.info("✅ Updated README.md with project details and origin info");
 }
@@ -184,39 +226,54 @@ async function injectAntigravityContext(rootPath, projectId, appName) {
     await fs.mkdir(rulesDir, { recursive: true });
     await fs.mkdir(workflowsDir, { recursive: true });
     await fs.mkdir(skillsDir, { recursive: true });
-    logger_1.logger.info("⏳ Fetching Antigravity skills from firebase/agent-skills...");
+    const installLocation = await prompt.select({
+        message: "Where would you like to install Firebase project skills?",
+        choices: [
+            { name: "Locally in the project", value: "local" },
+            { name: "Globally for all projects", value: "global" },
+        ],
+        default: "local",
+        nonInteractive: process.env.NODE_ENV === "test",
+    });
+    logger_1.logger.info("⏳ Adding Antigravity 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);
-                }
-            }
+        const args = [
+            "-y",
+            "skills",
+            "add",
+            "firebase/agent-skills",
+            "-a",
+            "gemini-cli",
+            "--skill",
+            "*",
+            "-y",
+        ];
+        if (installLocation === "global") {
+            args.push("-g");
         }
-        else {
-            utils.logWarning("GitHub API response for skills is not an array.");
+        const result = (0, child_process_1.spawnSync)("npx", args, {
+            cwd: rootPath,
+            stdio: "ignore",
+            shell: process.platform === "win32",
+        });
+        if (result.error) {
+            throw result.error;
+        }
+        if (result.status !== 0) {
+            throw new Error(`npx skills add exited with code ${result.status}`);
         }
-        logger_1.logger.info(`✅ Downloaded Firebase skills`);
+        logger_1.logger.info(`✅ Added Antigravity skills`);
     }
     catch (err) {
-        utils.logWarning(`Could not download Antigravity skills, skipping. ${err}`);
+        utils.logWarning(`Could not add Antigravity skills, 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);
+    const systemInstructions = systemInstructionsTemplate.replace("${appName}", appName);
     await fs.writeFile(path.join(rulesDir, "migration-context.md"), systemInstructions);
     logger_1.logger.info("✅ Injected Antigravity 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);
+        const cleanupWorkflow = await (0, templates_1.readTemplate)("firebase-studio-export/workflows/cleanup.md");
+        await fs.writeFile(path.join(workflowsDir, "cleanup.md"), cleanupWorkflow);
         logger_1.logger.info("✅ Created Antigravity startup workflow");
     }
     catch (err) {
@@ -282,12 +339,35 @@ async function createFirebaseConfigs(rootPath, projectId) {
             const backendsData = await apphosting.listBackends(projectId, "-");
             const backends = backendsData.backends || [];
             if (backends.length > 0) {
+                const backendIds = backends.map((b) => b.name.split("/").pop());
                 const studioBackend = backends.find((b) => b.name.endsWith("/studio") || b.name.toLowerCase().includes("studio"));
+                let selectedBackendId = "";
                 if (studioBackend) {
-                    backendId = studioBackend.name.split("/").pop();
+                    selectedBackendId = studioBackend.name.split("/").pop();
                 }
                 else {
-                    backendId = backends[0].name.split("/").pop();
+                    selectedBackendId = backendIds[0];
+                }
+                const confirmBackend = await prompt.confirm({
+                    message: `Would you like to use the App Hosting backend "${selectedBackendId}"?`,
+                    default: true,
+                    nonInteractive: process.env.NODE_ENV === "test",
+                });
+                if (confirmBackend) {
+                    backendId = selectedBackendId;
+                }
+                else {
+                    logger_1.logger.info("Available App Hosting backends:");
+                    for (const id of backendIds) {
+                        logger_1.logger.info(`  - ${id}`);
+                    }
+                    const inputBackendId = await prompt.input({
+                        message: "Please enter the name of the backend you would like to use:",
+                    });
+                    if (!backendIds.includes(inputBackendId)) {
+                        throw new error_1.FirebaseError(`Invalid backend selected: ${inputBackendId}`, { exit: 1 });
+                    }
+                    backendId = inputBackendId;
                 }
                 logger_1.logger.info(`✅ Selected App Hosting backend: ${backendId}`);
             }
@@ -317,20 +397,33 @@ async function createFirebaseConfigs(rootPath, projectId) {
         logger_1.logger.info(`✅ Created firebase.json with backendId: ${backendId}`);
     }
 }
-async function writeAntigravityConfigs(rootPath) {
+async function writeAntigravityConfigs(rootPath, framework) {
     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: [],
-            },
-        ],
+        tasks: [],
     };
+    if (framework === "FLUTTER") {
+        tasksJson.tasks.push({
+            label: "flutter-pub-get",
+            type: "shell",
+            command: "flutter pub get",
+            problemMatcher: [],
+            group: {
+                kind: "build",
+                isDefault: true,
+            },
+        });
+    }
+    else {
+        tasksJson.tasks.push({
+            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");
@@ -354,19 +447,43 @@ async function writeAntigravityConfigs(rootPath) {
     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",
-            },
-        ],
+        configurations: [],
     };
+    if (framework === "ANGULAR") {
+        launchJson.configurations.push({
+            type: "node",
+            request: "launch",
+            name: "Angular: debug server-side",
+            runtimeExecutable: "npm",
+            runtimeArgs: ["run", "start"],
+            port: 4200,
+            console: "integratedTerminal",
+            preLaunchTask: "npm-install",
+        });
+    }
+    else if (framework === "NEXT_JS") {
+        launchJson.configurations.push({
+            type: "node",
+            request: "launch",
+            name: "Next.js: debug server-side",
+            runtimeExecutable: "npm",
+            runtimeArgs: ["run", "dev"],
+            port: 9002,
+            console: "integratedTerminal",
+            preLaunchTask: "npm-install",
+        });
+    }
+    else if (framework === "FLUTTER") {
+        launchJson.configurations.push({
+            name: "Flutter",
+            request: "launch",
+            type: "dart",
+            preLaunchTask: "flutter-pub-get",
+        });
+    }
+    else {
+        return;
+    }
     await fs.writeFile(path.join(vscodeDir, "launch.json"), JSON.stringify(launchJson, null, 2));
     logger_1.logger.info("✅ Created .vscode/launch.json");
 }
@@ -392,6 +509,48 @@ async function cleanupUnusedFiles(rootPath) {
         const message = err instanceof Error ? err.message : String(err);
         logger_1.logger.debug(`Could not delete ${modifiedPath}: ${message}`);
     }
+    const mcpJsonPath = path.join(rootPath, ".idx", "mcp.json");
+    try {
+        await fs.unlink(mcpJsonPath);
+        logger_1.logger.info("✅ Cleaned up .idx/mcp.json");
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        logger_1.logger.debug(`Could not delete ${mcpJsonPath}: ${message}`);
+    }
+}
+async function upgradeGenkitVersion(rootPath) {
+    const packageJsonPath = path.join(rootPath, "package.json");
+    try {
+        const packageJsonContent = await fs.readFile(packageJsonPath, "utf8");
+        const packageJson = JSON.parse(packageJsonContent);
+        let modified = false;
+        const targetVersion = "1.29.0";
+        const checkAndUpgrade = (deps) => {
+            if (!deps || !deps["genkit-cli"]) {
+                return;
+            }
+            const currentVersion = deps["genkit-cli"];
+            if (currentVersion.startsWith("^")) {
+                return;
+            }
+            const coerced = semver.coerce(currentVersion);
+            if (coerced && semver.lt(coerced, targetVersion)) {
+                deps["genkit-cli"] = "^1.29";
+                modified = true;
+            }
+        };
+        checkAndUpgrade(packageJson.dependencies);
+        checkAndUpgrade(packageJson.devDependencies);
+        if (modified) {
+            await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n");
+            logger_1.logger.info("✅ Upgraded genkit-cli version to 1.29 in package.json");
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        logger_1.logger.debug(`Could not upgrade Genkit version: ${message}`);
+    }
 }
 async function uploadSecrets(rootPath, projectId) {
     if (!projectId) {
@@ -453,17 +612,37 @@ async function askToOpenAntigravity(rootPath, appName, startAntigravity) {
         }
     }
 }
+async function checkDirectoryExists(dir) {
+    try {
+        const stat = await fs.stat(dir);
+        if (!stat.isDirectory()) {
+            throw new error_1.FirebaseError(`The path ${dir} is not a directory.`, { exit: 1 });
+        }
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            throw new error_1.FirebaseError(`The directory ${dir} does not exist.`, { exit: 1 });
+        }
+        throw err;
+    }
+}
 async function migrate(rootPath, options = { startAntigravity: true }) {
+    await checkDirectoryExists(rootPath);
     const appType = await detectAppType(rootPath);
     void track.trackGA4("firebase_studio_migrate", { app_type: appType, result: "started" });
     logger_1.logger.info("🚀 Starting Firebase Studio to Antigravity migration...");
-    const { projectId, appName, blueprintContent } = await extractMetadata(rootPath, options.project);
-    await updateReadme(rootPath, blueprintContent, appName);
+    logger_1.logger.info("\nFile any bugs at https://github.com/firebase/firebase-tools/issues");
+    const { projectId, appName } = await extractMetadata(rootPath, options.project);
+    if (appType) {
+        logger_1.logger.info(`✅ Detected framework: ${appType}`);
+    }
+    await updateReadme(rootPath, appType);
     await createFirebaseConfigs(rootPath, projectId);
     await uploadSecrets(rootPath, projectId);
+    await upgradeGenkitVersion(rootPath);
     await injectAntigravityContext(rootPath, projectId, appName);
-    await writeAntigravityConfigs(rootPath);
-    await setupAntigravityMcpServer(rootPath);
+    await writeAntigravityConfigs(rootPath, appType);
+    await setupAntigravityMcpServer(rootPath, appType);
     await cleanupUnusedFiles(rootPath);
     const currentFolderName = path.basename(rootPath);
     if (currentFolderName === "download") {

package/lib/init/features/functions/dart.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setup = setup;
+const spawn = require("cross-spawn");
+const prompt_1 = require("../../../prompt");
+const supported_1 = require("../../../deploy/functions/runtimes/supported");
+const templates_1 = require("../../../templates");
+const PUBSPEC_TEMPLATE = (0, templates_1.readTemplateSync)("init/functions/dart/pubspec.yaml");
+const MAIN_TEMPLATE = (0, templates_1.readTemplateSync)("init/functions/dart/server.dart");
+const GITIGNORE_TEMPLATE = (0, templates_1.readTemplateSync)("init/functions/dart/_gitignore");
+async function setup(setup, config) {
+    await config.askWriteProjectFile(`${setup.functions.source}/pubspec.yaml`, PUBSPEC_TEMPLATE);
+    await config.askWriteProjectFile(`${setup.functions.source}/.gitignore`, GITIGNORE_TEMPLATE);
+    await config.askWriteProjectFile(`${setup.functions.source}/bin/server.dart`, MAIN_TEMPLATE);
+    config.set("functions.runtime", (0, supported_1.latest)("dart"));
+    config.set("functions.ignore", [".dart_tool", "build"]);
+    const install = await (0, prompt_1.confirm)({
+        message: "Do you want to install dependencies now?",
+        default: true,
+    });
+    if (install) {
+        const installProcess = spawn("dart", ["pub", "get"], {
+            cwd: config.path(setup.functions.source),
+            stdio: ["inherit", "inherit", "inherit"],
+        });
+        await new Promise((resolve, reject) => {
+            installProcess.on("exit", resolve);
+            installProcess.on("error", reject);
+        });
+    }
+}

package/lib/init/features/functions/index.js

@@ -144,6 +144,10 @@ async function languageSetup(setup) {
             value: "python",
         });
     }
+    choices.push({
+        name: "Dart",
+        value: "dart",
+    });
     const language = await (0, prompt_1.select)({
         message: "What language would you like to use to write Cloud Functions?",
         default: "javascript",
@@ -173,6 +177,16 @@ async function languageSetup(setup) {
             cbconfig.ignore = ["venv", ".git", "firebase-debug.log", "firebase-debug.*.log", "*.local"];
             cbconfig.runtime = supported.latest("python");
             break;
+        case "dart":
+            cbconfig.ignore = [
+                ".dart_tool",
+                ".git",
+                "firebase-debug.log",
+                "firebase-debug.*.log",
+                "*.local",
+            ];
+            cbconfig.runtime = supported.latest("dart");
+            break;
     }
     setup.functions.languageChoice = language;
 }

package/lib/mcp/index.js

@@ -135,7 +135,7 @@ class FirebaseMcpServer {
         this.logger.debug("detecting active features of Firebase MCP server...");
         const projectId = (await this.getProjectId()) || "";
         const accountEmail = await this.getAuthenticatedUser();
-        const isBillingEnabled = projectId ? await (0, cloudbilling_1.checkBillingEnabled)(projectId) : false;
+        const isBillingEnabled = projectId ? await this.safeCheckBillingEnabled(projectId) : false;
         const ctx = this._createMcpContext(projectId, accountEmail, isBillingEnabled);
         const detected = await Promise.all(types_1.SERVER_FEATURES.map(async (f) => {
             const availabilityCheck = (0, availability_1.getDefaultFeatureAvailabilityCheck)(f);
@@ -171,7 +171,7 @@ class FirebaseMcpServer {
     async getAvailableTools() {
         const projectId = (await this.getProjectId()) || "";
         const accountEmail = await this.getAuthenticatedUser();
-        const isBillingEnabled = projectId ? await (0, cloudbilling_1.checkBillingEnabled)(projectId) : false;
+        const isBillingEnabled = projectId ? await this.safeCheckBillingEnabled(projectId) : false;
         const ctx = this._createMcpContext(projectId, accountEmail, isBillingEnabled);
         return (0, index_2.availableTools)(ctx, this.activeFeatures, this.detectedFeatures, this.enabledTools);
     }
@@ -182,7 +182,7 @@ class FirebaseMcpServer {
     async getAvailablePrompts() {
         const projectId = (await this.getProjectId()) || "";
         const accountEmail = await this.getAuthenticatedUser();
-        const isBillingEnabled = projectId ? await (0, cloudbilling_1.checkBillingEnabled)(projectId) : false;
+        const isBillingEnabled = projectId ? await this.safeCheckBillingEnabled(projectId) : false;
         const ctx = this._createMcpContext(projectId, accountEmail, isBillingEnabled);
         return (0, index_1.availablePrompts)(ctx, this.activeFeatures, this.detectedFeatures);
     }
@@ -276,7 +276,7 @@ class FirebaseMcpServer {
         if (tool.mcp._meta?.requiresAuth && !accountEmail) {
             return (0, errors_1.mcpAuthError)(skipAutoAuthForStudio);
         }
-        const isBillingEnabled = projectId ? await (0, cloudbilling_1.checkBillingEnabled)(projectId) : false;
+        const isBillingEnabled = projectId ? await this.safeCheckBillingEnabled(projectId) : false;
         const toolsCtx = this._createMcpContext(projectId, accountEmail, isBillingEnabled);
         try {
             const res = await tool.fn(toolArgs, toolsCtx);
@@ -327,7 +327,7 @@ class FirebaseMcpServer {
         projectId = projectId || "";
         const skipAutoAuthForStudio = (0, env_1.isFirebaseStudio)();
         const accountEmail = await this.getAuthenticatedUser(skipAutoAuthForStudio);
-        const isBillingEnabled = projectId ? await (0, cloudbilling_1.checkBillingEnabled)(projectId) : false;
+        const isBillingEnabled = projectId ? await this.safeCheckBillingEnabled(projectId) : false;
         const promptsCtx = this._createMcpContext(projectId, accountEmail, isBillingEnabled);
         try {
             const messages = await prompt.fn(promptArgs, promptsCtx);
@@ -362,7 +362,7 @@ class FirebaseMcpServer {
         projectId = projectId || "";
         const skipAutoAuthForStudio = (0, env_1.isFirebaseStudio)();
         const accountEmail = await this.getAuthenticatedUser(skipAutoAuthForStudio);
-        const isBillingEnabled = projectId ? await (0, cloudbilling_1.checkBillingEnabled)(projectId) : false;
+        const isBillingEnabled = projectId ? await this.safeCheckBillingEnabled(projectId) : false;
         const resourceCtx = this._createMcpContext(projectId, accountEmail, isBillingEnabled);
         const resolved = await (0, resources_1.resolveResource)(req.params.uri, resourceCtx);
         if (!resolved) {
@@ -376,6 +376,18 @@ class FirebaseMcpServer {
             : new stdio_js_1.StdioServerTransport();
         await this.server.connect(transport);
     }
+    async safeCheckBillingEnabled(projectId) {
+        try {
+            return await (0, cloudbilling_1.checkBillingEnabled)(projectId);
+        }
+        catch (e) {
+            this.logger.debug("[mcp] Error on billingInfo for " +
+                projectId +
+                ", failing open (assuming false): " +
+                (e.message || e));
+            return false;
+        }
+    }
     get logger() {
         const logAtLevel = (level, message) => {
             let data = message;