firebase-tools 15.15.0 → 15.16.0

package/lib/init/features/dataconnect/sdk.js

@@ -26,11 +26,11 @@ const cloudbilling_1 = require("../../../gcp/cloudbilling");
 exports.FDC_APP_FOLDER = "FDC_APP_FOLDER";
 exports.FDC_SDK_FRAMEWORKS_ENV = "FDC_SDK_FRAMEWORKS";
 exports.FDC_SDK_PLATFORM_ENV = "FDC_SDK_PLATFORM";
-async function askQuestions(setup) {
+async function askQuestions(setup, config, options) {
     const info = {
         apps: [],
     };
-    info.apps = await chooseApp();
+    info.apps = await chooseApp(options);
     if (!info.apps.length) {
         const npxMissingWarning = (0, utils_1.commandExistsSync)("npx")
             ? ""
@@ -46,6 +46,8 @@ async function askQuestions(setup) {
                 { name: `Flutter${flutterMissingWarning}`, value: "flutter" },
                 { name: "skip", value: "skip" },
             ],
+            default: "skip",
+            nonInteractive: options?.nonInteractive,
         });
         try {
             switch (choice) {
@@ -69,7 +71,7 @@ async function askQuestions(setup) {
     setup.featureInfo = setup.featureInfo || {};
     setup.featureInfo.dataconnectSdk = info;
 }
-async function chooseApp() {
+async function chooseApp(options) {
     let apps = dedupeAppsByPlatformAndDirectory(await (0, appUtils_1.detectApps)(cwd));
     if (apps.length) {
         (0, utils_1.logLabeledSuccess)("dataconnect", `Detected existing apps ${apps.map((a) => (0, appUtils_1.appDescription)(a)).join(", ")}`);
@@ -108,9 +110,12 @@ async function chooseApp() {
                 checked: a.directory === ".",
             };
         });
+        const defaultApps = choices.filter((c) => c.checked).map((c) => c.value);
         const pickedApps = await (0, prompt_1.checkbox)({
             message: "Which apps do you want to set up SQL Connect SDKs in?",
             choices,
+            default: defaultApps.length > 0 ? defaultApps : [choices[0].value],
+            nonInteractive: options?.nonInteractive,
             validate: (choices) => {
                 if (choices.length === 0) {
                     return "Please choose at least one app.";

package/lib/init/features/firestore/rules.js

@@ -39,7 +39,8 @@ async function initRules(setup, config, info) {
     info.writeRules = await config.confirmWriteProjectFile(info.rulesFilename, info.rules);
 }
 async function getRulesFromConsole(projectId) {
-    const name = await gcp.rules.getLatestRulesetName(projectId, "cloud.firestore");
+    const releases = await gcp.rules.listAllReleases(projectId);
+    const name = await gcp.rules.getLatestRulesetName(projectId, "cloud.firestore", releases);
     if (!name) {
         return null;
     }

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

@@ -8,9 +8,11 @@ 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");
+const ANALYSIS_OPTIONS_TEMPLATE = (0, templates_1.readTemplateSync)("init/functions/dart/analysis_options.yaml");
 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}/analysis_options.yaml`, ANALYSIS_OPTIONS_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"]);

package/lib/init/features/storage/rules.js

@@ -5,7 +5,8 @@ const gcp = require("../../../gcp");
 const utils = require("../../../utils");
 async function getRulesFromConsole(projectId) {
     const defaultBucket = await gcp.storage.getDefaultBucket(projectId);
-    const name = await gcp.rules.getLatestRulesetName(projectId, "firebase.storage", defaultBucket);
+    const releases = await gcp.rules.listAllReleases(projectId);
+    const name = await gcp.rules.getLatestRulesetName(projectId, "firebase.storage", releases, defaultBucket);
     if (!name) {
         return null;
     }

package/lib/mcp/apps/update_environment/mcp-app.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ext_apps_1 = require("@modelcontextprotocol/ext-apps");
+const app = new ext_apps_1.App({ name: "Update Firebase Environment", version: "1.0.0" });
+const projectListContainer = document.getElementById("project-list");
+const searchInput = document.getElementById("search-input");
+const submitBtn = document.getElementById("submit-btn");
+const statusBox = document.getElementById("status-box");
+let projects = [];
+let filteredProjects = [];
+let selectedProjectId = null;
+const envProjectIdEl = document.getElementById("env-project-id");
+const envUserEl = document.getElementById("env-user");
+function showStatus(message, type) {
+    statusBox.textContent = message;
+    statusBox.className = `status ${type}`;
+    statusBox.style.display = "block";
+}
+function renderProjects() {
+    projectListContainer.innerHTML = "";
+    if (filteredProjects.length === 0) {
+        projectListContainer.innerHTML = `
+      <div class="dropdown-item" style="cursor: default;">
+        <div class="item-name">No projects found.</div>
+      </div>
+    `;
+        return;
+    }
+    filteredProjects.forEach((p) => {
+        const item = document.createElement("div");
+        item.className = "dropdown-item";
+        if (p.projectId === selectedProjectId) {
+            item.classList.add("selected");
+        }
+        const displayName = p.displayName || p.projectId;
+        const projectId = p.projectId;
+        item.innerHTML = `
+      <div class="item-name">${displayName}</div>
+      <div class="item-id">${projectId}</div>
+    `;
+        item.onclick = () => {
+            selectedProjectId = projectId;
+            submitBtn.disabled = false;
+            renderProjects();
+        };
+        projectListContainer.appendChild(item);
+    });
+}
+searchInput.oninput = () => {
+    const query = searchInput.value.toLowerCase().trim();
+    if (query === "") {
+        filteredProjects = projects;
+    }
+    else {
+        filteredProjects = projects.filter((p) => {
+            const name = (p.displayName || p.projectId).toLowerCase();
+            const id = p.projectId.toLowerCase();
+            return name.includes(query) || id.includes(query);
+        });
+    }
+    renderProjects();
+};
+submitBtn.onclick = async () => {
+    if (!selectedProjectId)
+        return;
+    submitBtn.disabled = true;
+    showStatus(`Updating active project to ${selectedProjectId}...`, "info");
+    try {
+        const result = await app.callServerTool({
+            name: "firebase_update_environment",
+            arguments: { active_project: selectedProjectId },
+        });
+        const textContent = result.content?.find((c) => c.type === "text");
+        const text = textContent ? textContent.text : "Update complete.";
+        if (result.isError) {
+            showStatus(text, "error");
+            submitBtn.disabled = false;
+        }
+        else {
+            showStatus(text, "success");
+        }
+    }
+    catch (err) {
+        showStatus(`Error updating environment: ${err.message}`, "error");
+        submitBtn.disabled = false;
+    }
+};
+app.onhostcontextchanged = (ctx) => {
+    if (ctx.theme)
+        (0, ext_apps_1.applyDocumentTheme)(ctx.theme);
+    if (ctx.styles?.variables)
+        (0, ext_apps_1.applyHostStyleVariables)(ctx.styles.variables);
+    if (ctx.styles?.css?.fonts)
+        (0, ext_apps_1.applyHostFonts)(ctx.styles.css.fonts);
+    if (ctx.safeAreaInsets) {
+        const { top, right, bottom, left } = ctx.safeAreaInsets;
+        document.body.style.padding = `${top}px ${right}px ${bottom}px ${left}px`;
+    }
+};
+(async () => {
+    try {
+        await app.connect();
+        showStatus("Connecting to server...", "info");
+        try {
+            const envResult = await app.callServerTool({
+                name: "firebase_get_environment",
+                arguments: {},
+            });
+            const envData = envResult.structuredContent;
+            if (envData) {
+                envProjectIdEl.textContent = envData.projectId || "<NONE>";
+                envUserEl.textContent = envData.authenticatedUser || "<NONE>";
+            }
+        }
+        catch (err) {
+            console.error("Failed to fetch environment:", err);
+            showStatus(`Failed to fetch environment: ${err.message}`, "error");
+        }
+        const result = await app.callServerTool({ name: "firebase_list_projects", arguments: {} });
+        const data = result.structuredContent;
+        if (data && data.projects) {
+            projects = data.projects;
+            filteredProjects = projects;
+            renderProjects();
+            showStatus("Projects loaded successfully.", "success");
+            setTimeout(() => {
+                if (statusBox.className === "status success")
+                    statusBox.style.display = "none";
+            }, 3000);
+        }
+        else {
+            showStatus("No projects returned from server.", "error");
+        }
+    }
+    catch (err) {
+        showStatus(`Failed to load projects: ${err.message}`, "error");
+    }
+})();

package/lib/mcp/index.js

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FirebaseMcpServer = void 0;
 const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const sse_js_1 = require("@modelcontextprotocol/sdk/server/sse.js");
+const express_1 = require("express");
+const cors_1 = require("cors");
 const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
 const crossSpawn = require("cross-spawn");
 const node_fs_1 = require("node:fs");
@@ -278,6 +281,9 @@ class FirebaseMcpServer {
         }
         const isBillingEnabled = projectId ? await this.safeCheckBillingEnabled(projectId) : false;
         const toolsCtx = this._createMcpContext(projectId, accountEmail, isBillingEnabled);
+        if (request.params._meta?.progressToken) {
+            toolsCtx.progressToken = request.params._meta.progressToken;
+        }
         try {
             const res = await tool.fn(toolArgs, toolsCtx);
             await this.trackGA4("mcp_tool_call", {
@@ -370,7 +376,56 @@ class FirebaseMcpServer {
         }
         return resolved.result;
     }
-    async start() {
+    async start(options) {
+        if (options?.useSSE) {
+            const app = (0, express_1.default)();
+            app.use((0, cors_1.default)());
+            const port = options.port || 3000;
+            const transports = {};
+            app.get("/sse", async (req, res) => {
+                this.logger.debug(`[SSE] GET /sse connection attempt from ${req.ip}`);
+                try {
+                    const transport = new sse_js_1.SSEServerTransport("/message", res);
+                    const sessionId = transport.sessionId;
+                    transports[sessionId] = transport;
+                    this.logger.debug(`[SSE] Connected session ${sessionId}`);
+                    await this.server.connect(transport);
+                    this.logger.debug(`[SSE] Server connected to transport`);
+                    await new Promise((resolve) => {
+                        req.on("close", () => {
+                            this.logger.debug(`[SSE] Session ${sessionId} disconnected`);
+                            delete transports[sessionId];
+                            resolve();
+                        });
+                    });
+                }
+                catch (err) {
+                    this.logger.error(`[SSE] Connection error: ${err}`);
+                }
+            });
+            app.post("/message", async (req, res) => {
+                const sessionId = req.query.sessionId;
+                this.logger.debug(`[SSE] POST /message attempt for session ${sessionId}`);
+                const transport = transports[sessionId];
+                if (transport) {
+                    try {
+                        await transport.handlePostMessage(req, res);
+                        this.logger.debug(`[SSE] Handled message for session ${sessionId}`);
+                    }
+                    catch (err) {
+                        this.logger.error(`[SSE] Error handling message for session ${sessionId}: ${err}`);
+                    }
+                }
+                else {
+                    this.logger.error(`[SSE] Rejecting message: No active transport found for session ${sessionId}`);
+                    res.status(400).send("No active SSE transport connection found for this session");
+                }
+            });
+            app.listen(port, "127.0.0.1", () => {
+                this.logger.info(`MCP Server running on HTTP/SSE mode at http://127.0.0.1:${port}`);
+            });
+            return;
+        }
         const transport = process.env.FIREBASE_MCP_DEBUG_LOG
             ? new logging_transport_1.LoggingStdioServerTransport(process.env.FIREBASE_MCP_DEBUG_LOG)
             : new stdio_js_1.StdioServerTransport();
@@ -384,7 +439,7 @@ class FirebaseMcpServer {
             this.logger.debug("[mcp] Error on billingInfo for " +
                 projectId +
                 ", failing open (assuming false): " +
-                (e.message || e));
+                (e instanceof Error ? e.message : String(e)));
             return false;
         }
     }

package/lib/mcp/resources/index.js

@@ -15,6 +15,7 @@ const crashlytics_investigations_1 = require("./guides/crashlytics_investigation
 const track_1 = require("../../track");
 const crashlytics_issues_1 = require("./guides/crashlytics_issues");
 const crashlytics_reports_1 = require("./guides/crashlytics_reports");
+const update_environment_ui_1 = require("./update_environment_ui");
 exports.resources = [
     app_id_1.app_id,
     crashlytics_investigations_1.crashlytics_investigations,
@@ -26,6 +27,7 @@ exports.resources = [
     init_firestore_rules_1.init_firestore_rules,
     init_auth_1.init_auth,
     init_hosting_1.init_hosting,
+    update_environment_ui_1.update_environment_ui,
 ];
 exports.resourceTemplates = [docs_1.docs];
 async function resolveResource(uri, ctx, track = true) {

package/lib/mcp/resources/update_environment_ui.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.update_environment_ui = void 0;
+const resource_1 = require("../resource");
+const path = require("path");
+const fs = require("fs/promises");
+const util_1 = require("../util");
+const resourceUri = "ui://core/update_environment/mcp-app.html";
+exports.update_environment_ui = (0, resource_1.resource)({
+    uri: resourceUri,
+    name: "Update Environment UI",
+    description: "Visual interface for selecting active Firebase project",
+    mimeType: util_1.RESOURCE_MIME_TYPE,
+}, async () => {
+    try {
+        const htmlPath = path.join(__dirname, "../apps/update_environment/mcp-app.html");
+        const html = await fs.readFile(htmlPath, "utf-8");
+        return {
+            contents: [
+                {
+                    uri: resourceUri,
+                    mimeType: util_1.RESOURCE_MIME_TYPE,
+                    text: html,
+                },
+            ],
+        };
+    }
+    catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        throw new Error(`Failed to load Update Environment UI: ${message}`);
+    }
+});

package/lib/mcp/tools/core/get_security_rules.js

@@ -46,7 +46,8 @@ exports.get_security_rules = (0, tool_1.tool)("core", {
         storage: { productName: "Storage", releaseName: "firebase.storage" },
     };
     const { productName, releaseName } = serviceInfo[type];
-    const rulesetName = await (0, rules_1.getLatestRulesetName)(projectId, releaseName);
+    const releases = await (0, rules_1.listAllReleases)(projectId);
+    const rulesetName = await (0, rules_1.getLatestRulesetName)(projectId, releaseName, releases);
     if (!rulesetName)
         return (0, util_1.mcpError)(`No active ${productName} rules were found in project '${projectId}'`);
     const rules = await (0, rules_1.getRulesetContent)(rulesetName);

package/lib/mcp/util.js

@@ -1,10 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.RESOURCE_MIME_TYPE = void 0;
 exports.toContent = toContent;
+exports.applyAppMeta = applyAppMeta;
 exports.mcpError = mcpError;
 exports.checkFeatureActive = checkFeatureActive;
 exports.cleanSchema = cleanSchema;
 const js_yaml_1 = require("js-yaml");
+const experiments = require("../experiments");
 const api_1 = require("../api");
 const ensureApiEnabled_1 = require("../ensureApiEnabled");
 const timeout_1 = require("../timeout");
@@ -25,8 +28,23 @@ function toContent(data, options) {
     const suffix = options?.contentSuffix || "";
     return {
         content: [{ type: "text", text: `${prefix}${text}${suffix}` }],
+        structuredContent: data,
     };
 }
+function applyAppMeta(result, resourceUri) {
+    if (experiments.isEnabled("mcpapps")) {
+        return {
+            ...result,
+            _meta: {
+                ...result._meta,
+                ui: {
+                    resourceUri,
+                },
+            },
+        };
+    }
+    return result;
+}
 function mcpError(message, code) {
     let errorMessage = "unknown error";
     if (message instanceof Error) {
@@ -223,3 +241,4 @@ function cleanSchema(schema) {
     const result = deepClean(schema, true);
     return result === null ? {} : result;
 }
+exports.RESOURCE_MIME_TYPE = "application/vnd.mcp.ext-app+html";

package/lib/rulesDeploy.js

@@ -30,10 +30,10 @@ class RulesDeploy {
         this.options = options;
         this.type = type;
         this.project = options.project;
-        this.rulesFiles = {};
+        this.rulesFiles = [];
         this.rulesetNames = {};
     }
-    addFile(path) {
+    addFile(path, databaseId) {
         const fullPath = this.options.config.path(path);
         let src;
         try {
@@ -43,15 +43,15 @@ class RulesDeploy {
             logger_1.logger.debug("[rules read error]", e.stack);
             throw new error_1.FirebaseError(`Error reading rules file ${(0, colorette_1.bold)(path)}`);
         }
-        this.rulesFiles[path] = [{ name: path, content: src }];
+        this.rulesFiles.push({ path, files: [{ name: path, content: src }], databaseId });
     }
     async compile() {
-        await Promise.all(Object.keys(this.rulesFiles).map((filename) => {
-            return this.compileRuleset(filename, this.rulesFiles[filename]);
+        await Promise.all(this.rulesFiles.map((entry) => {
+            return this.compileRuleset(entry.path, entry.files);
         }));
     }
-    async getCurrentRules(service) {
-        const latestName = await gcp.rules.getLatestRulesetName(this.options.project, service);
+    async getCurrentRules(service, releases, databaseId) {
+        const latestName = await gcp.rules.getLatestRulesetName(this.options.project, service, releases, databaseId);
         let latestContent = null;
         if (latestName) {
             latestContent = await gcp.rules.getRulesetContent(latestName);
@@ -88,24 +88,37 @@ class RulesDeploy {
     }
     async createRulesets(service) {
         const createdRulesetNames = [];
-        const { latestName: latestRulesetName, latestContent: latestRulesetContent } = await this.getCurrentRules(service);
-        const newRulesetsByFilename = new Map();
-        for (const [filename, files] of Object.entries(this.rulesFiles)) {
+        const releases = await gcp.rules.listAllReleases(this.options.project);
+        const newRulesetsByKey = new Map();
+        for (const entry of this.rulesFiles) {
+            const { path: filename, files, databaseId } = entry;
+            const normalizedDatabaseId = databaseId === "(default)" ? undefined : databaseId;
+            const { latestName: latestRulesetName, latestContent: latestRulesetContent } = await this.getCurrentRules(service, releases, normalizedDatabaseId);
+            const key = this.type === RulesetServiceType.FIREBASE_STORAGE
+                ? filename
+                : `${filename}:${databaseId || ""}`;
             if (latestRulesetName && _.isEqual(files, latestRulesetContent)) {
                 utils.logLabeledBullet(RulesetType[this.type], `latest version of ${(0, colorette_1.bold)(filename)} already up to date, skipping upload...`);
-                this.rulesetNames[filename] = latestRulesetName;
+                this.rulesetNames[key] = latestRulesetName;
                 continue;
             }
             if (service === RulesetServiceType.FIREBASE_STORAGE) {
                 await this.checkStorageRulesIamPermissions(files[0]?.content);
             }
             utils.logLabeledBullet(RulesetType[this.type], `uploading rules ${(0, colorette_1.bold)(filename)}...`);
-            newRulesetsByFilename.set(filename, gcp.rules.createRuleset(this.options.project, files));
+            let attachmentPoint;
+            if (this.type === RulesetServiceType.CLOUD_FIRESTORE &&
+                databaseId &&
+                databaseId !== "(default)") {
+                const projectNumber = await (0, getProjectNumber_1.getProjectNumber)(this.options);
+                attachmentPoint = `firestore.googleapis.com/projects/${projectNumber}/databases/${databaseId}`;
+            }
+            newRulesetsByKey.set(key, gcp.rules.createRuleset(this.options.project, files, attachmentPoint));
         }
         try {
-            await Promise.all(newRulesetsByFilename.values());
-            for (const [filename, rulesetName] of newRulesetsByFilename) {
-                this.rulesetNames[filename] = await rulesetName;
+            await Promise.all(newRulesetsByKey.values());
+            for (const [key, rulesetName] of newRulesetsByKey) {
+                this.rulesetNames[key] = await rulesetName;
                 createdRulesetNames.push(await rulesetName);
             }
         }
@@ -141,7 +154,13 @@ class RulesDeploy {
         if (resourceName === RulesetServiceType.FIREBASE_STORAGE && !subResourceName) {
             throw new error_1.FirebaseError(`Cannot release resource type "${resourceName}"`);
         }
-        await gcp.rules.updateOrCreateRelease(this.options.project, this.rulesetNames[filename], subResourceName ? `${resourceName}/${subResourceName}` : resourceName);
+        const key = this.type === RulesetServiceType.FIREBASE_STORAGE
+            ? filename
+            : `${filename}:${subResourceName || ""}`;
+        const releaseName = subResourceName && subResourceName !== "(default)"
+            ? `${resourceName}/${subResourceName}`
+            : resourceName;
+        await gcp.rules.updateOrCreateRelease(this.options.project, this.rulesetNames[key], releaseName);
         utils.logLabeledSuccess(RulesetType[this.type], `released rules ${(0, colorette_1.bold)(filename)} to ${(0, colorette_1.bold)(resourceName)}`);
     }
     async compileRuleset(filename, files) {