feat(mcp): Automatically detect features. (#8552)

Author: mbleigh

src/api.ts

@@ -52,6 +52,8 @@ export const apphostingGitHubAppInstallationURL = () =>
 
 export const authOrigin = () =>
   utils.envOverride("FIREBASE_AUTH_URL", "https://accounts.google.com");
+export const authManagementOrigin = () =>
+  utils.envOverride("FIREBASE_AUTH_MANAGEMENT_URL", "https://identitytoolkit.googleapis.com");
 export const consoleOrigin = () =>
   utils.envOverride("FIREBASE_CONSOLE_URL", "https://console.firebase.google.com");
 export const dynamicLinksOrigin = () =>

src/experiments.ts

@@ -131,7 +131,7 @@ export const ALL_EXPERIMENTS = experiments({
   },
   mcp: {
     shortDescription: "Adds experimental `firebase mcp` command for running a Firebase MCP server.",
-    default: false,
+    default: true,
     public: false,
   },
 });

src/mcp/index.ts

@@ -7,8 +7,8 @@ import {
   ListToolsRequestSchema,
   ListToolsResult,
 } from "@modelcontextprotocol/sdk/types.js";
-import { mcpError } from "./util.js";
-import { ServerFeature } from "./types.js";
+import { checkFeatureActive, mcpError } from "./util.js";
+import { SERVER_FEATURES, ServerFeature } from "./types.js";
 import { availableTools } from "./tools/index.js";
 import { ServerTool } from "./tool.js";
 import { configstore } from "../configstore.js";
@@ -30,6 +30,7 @@ export class FirebaseMcpServer {
   projectRoot?: string;
   server: Server;
   activeFeatures?: ServerFeature[];
+  detectedFeatures?: ServerFeature[];
   fixedRoot?: boolean;
 
   constructor(options: { activeFeatures?: ServerFeature[]; projectRoot?: string }) {
@@ -44,30 +45,34 @@ export class FirebaseMcpServer {
       process.env.PROJECT_ROOT ??
       process.cwd();
     if (options.projectRoot) this.fixedRoot = true;
+    this.detectActiveFeatures();
+  }
+
+  async detectActiveFeatures(): Promise<ServerFeature[]> {
+    if (this.detectedFeatures?.length) return this.detectedFeatures; // memoized
+    const options = await this.resolveOptions();
+    const projectId = await this.getProjectId();
+    const detected = await Promise.all(
+      SERVER_FEATURES.map(async (f) => {
+        if (await checkFeatureActive(f, projectId, options)) return f;
+        return null;
+      }),
+    );
+    this.detectedFeatures = detected.filter((f) => !!f) as ServerFeature[];
+    return this.detectedFeatures;
   }
 
   get availableTools(): ServerTool[] {
-    return availableTools(!!this.fixedRoot, this.activeFeatures);
+    return availableTools(
+      !!this.fixedRoot,
+      this.activeFeatures?.length ? this.activeFeatures : this.detectedFeatures,
+    );
   }
 
   getTool(name: string): ServerTool | null {
     return this.availableTools.find((t) => t.mcp.name === name) || null;
   }
 
-  async mcpListTools(): Promise<ListToolsResult> {
-    const hasActiveProject = !!(await this.getProjectId());
-    await trackGA4("mcp_list_tools", {});
-    return {
-      tools: this.availableTools.map((t) => t.mcp),
-      _meta: {
-        projectRoot: this.projectRoot,
-        projectDetected: hasActiveProject,
-        authenticated: await this.getAuthenticated(),
-        activeFeatures: this.activeFeatures,
-      },
-    };
-  }
-
   setProjectRoot(newRoot: string | null): void {
     if (newRoot === null) {
       configstore.delete(PROJECT_ROOT_KEY);
@@ -78,6 +83,7 @@ export class FirebaseMcpServer {
 
     configstore.set(PROJECT_ROOT_KEY, newRoot);
     this.projectRoot = newRoot;
+    this.detectedFeatures = undefined; // reset detected features
     void this.server.sendToolListChanged();
   }
 
@@ -100,6 +106,22 @@ export class FirebaseMcpServer {
     }
   }
 
+  async mcpListTools(): Promise<ListToolsResult> {
+    if (!this.activeFeatures) await this.detectActiveFeatures();
+    const hasActiveProject = !!(await this.getProjectId());
+    await trackGA4("mcp_list_tools", {});
+    return {
+      tools: this.availableTools.map((t) => t.mcp),
+      _meta: {
+        projectRoot: this.projectRoot,
+        projectDetected: hasActiveProject,
+        authenticated: await this.getAuthenticated(),
+        activeFeatures: this.activeFeatures,
+        detectedFeatures: this.detectedFeatures,
+      },
+    };
+  }
+
   async mcpCallTool(request: CallToolRequest): Promise<CallToolResult> {
     const toolName = request.params.name;
     const toolArgs = request.params.arguments;

src/mcp/tools/index.ts

@@ -15,7 +15,7 @@ export function availableTools(fixedRoot: boolean, activeFeatures?: ServerFeatur
     // Present if the root is not fixed.
     toolDefs.push(...directoryTools);
   }
-  if (!activeFeatures || !activeFeatures.length) {
+  if (!activeFeatures?.length) {
     activeFeatures = Object.keys(tools) as ServerFeature[];
   }
   for (const key of activeFeatures) {

src/mcp/util.ts

@@ -2,6 +2,9 @@ import { CallToolResult } from "@modelcontextprotocol/sdk/types";
 import { execSync } from "child_process";
 import { dump } from "js-yaml";
 import { platform } from "os";
+import { ServerFeature } from "./types";
+import { authManagementOrigin, dataconnectOrigin, firestoreOrigin, storageOrigin } from "../api";
+import { check } from "../ensureApiEnabled";
 
 export function toContent(data: any, options?: { format: "json" | "yaml" }): CallToolResult {
   if (typeof data === "string") return { content: [{ type: "text", text: data }] };
@@ -53,3 +56,30 @@ export function commandExistsSync(command: string): boolean {
     return false;
   }
 }
+
+const SERVER_FEATURE_APIS: Record<ServerFeature, string> = {
+  firestore: firestoreOrigin(),
+  storage: storageOrigin(),
+  dataconnect: dataconnectOrigin(),
+  auth: authManagementOrigin(),
+};
+/**
+ * Detects whether an MCP feature is active in the current project root. Relies first on
+ * `firebase.json` configuration, but falls back to API checks.
+ */
+export async function checkFeatureActive(
+  feature: ServerFeature,
+  projectId?: string,
+  options?: any,
+): Promise<boolean> {
+  // if the feature is configured in firebase.json, it's active
+  if (feature in (options?.config?.data || {})) return true;
+  // if the feature's api is active in the project, it's active
+  try {
+    if (projectId) return await check(projectId, SERVER_FEATURE_APIS[feature], "", true);
+  } catch (e) {
+    // if we don't have network or something, better to default to on
+    return true;
+  }
+  return false;
+}