feat(mcp): fine grained control over tool loading

--tools will override discovery and provide only the listed tools

Author: MichaelDoyle

src/bin/mcp.ts

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 
+import { resolve } from "path";
+import { parseArgs } from "util";
 import { useFileLogger } from "../logger";
 import { FirebaseMcpServer } from "../mcp/index";
-import { parseArgs } from "util";
-import { SERVER_FEATURES, ServerFeature } from "../mcp/types";
-import { markdownDocsOfTools } from "../mcp/tools/index.js";
 import { markdownDocsOfPrompts } from "../mcp/prompts/index.js";
 import { markdownDocsOfResources } from "../mcp/resources/index.js";
-import { resolve } from "path";
+import { markdownDocsOfTools } from "../mcp/tools/index.js";
+import { SERVER_FEATURES, ServerFeature } from "../mcp/types";
 
 const STARTUP_MESSAGE = `
 This is a running process of the Firebase MCP server. This command should only be executed by an MCP client. An example MCP client configuration might be:
@@ -22,19 +22,55 @@ This is a running process of the Firebase MCP server. This command should only b
 }
 `;
 
+const HELP_TEXT = `Usage: firebase mcp [options]
+
+Description:
+  Starts the Model Context Protocol (MCP) server for the Firebase CLI. This server provides a
+  standardized way for AI agents and IDEs to interact with your Firebase project.
+
+Tool Discovery & Loading:
+  The server automatically determines which tools to expose based on your project context.
+
+  1. Auto-Detection (Default):
+     - Scans 'firebase.json' for configured services (e.g., Hosting, Firestore).
+     - Checks enabled Google Cloud APIs for the active project.
+     - Inspects project files for specific SDKs (e.g., Crashlytics in Android/iOS).
+
+  2. Manual Overrides:
+     - Use '--only' to restrict tool discovery to specific feature sets (e.g., core, firestore).
+     - Use '--tools' to disable auto-detection entirely and load specific tools by name.
+
+Options:
+  --dir <path>              Project root directory (defaults to current working directory).
+  --only <features>         Comma-separated list of features to enable (e.g. core, firestore).
+                            If specified, auto-detection is disabled for other features.
+  --tools <tools>           Comma-separated list of specific tools to enable. Disables
+                            auto-detection entirely.
+  --generate-tool-list      Generate markdown documentation for all available tools.
+  --generate-prompt-list    Generate markdown documentation for all available prompts.
+  --generate-resource-list  Generate markdown documentation for all available resources.
+  -h, --help                Show this help message.
+`;
+
 export async function mcp(): Promise<void> {
   const { values } = parseArgs({
     options: {
       only: { type: "string", default: "" },
+      tools: { type: "string", default: "" },
       dir: { type: "string" },
       "generate-tool-list": { type: "boolean", default: false },
       "generate-prompt-list": { type: "boolean", default: false },
       "generate-resource-list": { type: "boolean", default: false },
+      help: { type: "boolean", default: false, short: "h" },
     },
     allowPositionals: true,
   });
 
   let earlyExit = false;
+  if (values.help) {
+    console.log(HELP_TEXT);
+    earlyExit = true;
+  }
   if (values["generate-tool-list"]) {
     console.log(markdownDocsOfTools());
     earlyExit = true;
@@ -54,8 +90,10 @@ export async function mcp(): Promise<void> {
   const activeFeatures = (values.only || "")
     .split(",")
     .filter((f) => SERVER_FEATURES.includes(f as ServerFeature)) as ServerFeature[];
+  const enabledTools = (values.tools || "").split(",").filter((t) => t.length > 0);
   const server = new FirebaseMcpServer({
     activeFeatures,
+    enabledTools,
     projectRoot: values.dir ? resolve(values.dir) : undefined,
   });
   await server.start();

src/mcp/index.ts

@@ -3,49 +3,49 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import {
   CallToolRequest,
   CallToolRequestSchema,
-  ListToolsResult,
-  LoggingLevel,
-  SetLevelRequestSchema,
-  ListToolsRequestSchema,
   CallToolResult,
-  ListPromptsRequestSchema,
+  ErrorCode,
+  GetPromptRequest,
   GetPromptRequestSchema,
-  ListPromptsResult,
   GetPromptResult,
-  GetPromptRequest,
+  ListPromptsRequestSchema,
+  ListPromptsResult,
   ListResourcesRequestSchema,
   ListResourcesResult,
-  ReadResourceRequest,
-  ReadResourceResult,
-  ReadResourceRequestSchema,
   ListResourceTemplatesRequestSchema,
   ListResourceTemplatesResult,
+  ListToolsRequestSchema,
+  ListToolsResult,
+  LoggingLevel,
   McpError,
-  ErrorCode,
+  ReadResourceRequest,
+  ReadResourceRequestSchema,
+  ReadResourceResult,
+  SetLevelRequestSchema,
 } from "@modelcontextprotocol/sdk/types.js";
-import { mcpError } from "./util";
-import { ClientConfig, McpContext, SERVER_FEATURES, ServerFeature } from "./types";
-import { availableTools } from "./tools/index";
-import { ServerTool } from "./tool";
-import { availablePrompts } from "./prompts/index";
-import { ServerPrompt } from "./prompt";
-import { configstore } from "../configstore";
+import * as crossSpawn from "cross-spawn";
+import { existsSync } from "node:fs";
 import { Command } from "../command";
-import { requireAuth } from "../requireAuth";
-import { Options } from "../options";
-import { getProjectId } from "../projectUtils";
-import { mcpAuthError, noProjectDirectory, NO_PROJECT_ERROR, requireGeminiToS } from "./errors";
-import { trackGA4 } from "../track";
 import { Config } from "../config";
-import { loadRC } from "../rc";
+import { configstore } from "../configstore";
 import { EmulatorHubClient } from "../emulator/hubClient";
 import { Emulators } from "../emulator/types";
-import { existsSync } from "node:fs";
-import { LoggingStdioServerTransport } from "./logging-transport";
 import { isFirebaseStudio } from "../env";
+import { Options } from "../options";
+import { getProjectId } from "../projectUtils";
+import { loadRC } from "../rc";
+import { requireAuth } from "../requireAuth";
 import { timeoutFallback } from "../timeout";
+import { trackGA4 } from "../track";
+import { mcpAuthError, NO_PROJECT_ERROR, noProjectDirectory, requireGeminiToS } from "./errors";
+import { LoggingStdioServerTransport } from "./logging-transport";
+import { ServerPrompt } from "./prompt";
+import { availablePrompts } from "./prompts/index";
 import { resolveResource, resources, resourceTemplates } from "./resources";
-import * as crossSpawn from "cross-spawn";
+import { ServerTool } from "./tool";
+import { availableTools } from "./tools/index";
+import { ClientConfig, McpContext, SERVER_FEATURES, ServerFeature } from "./types";
+import { mcpError } from "./util";
 import { getDefaultFeatureAvailabilityCheck } from "./util/availability";
 
 const SERVER_VERSION = "0.3.0";
@@ -72,6 +72,7 @@ export class FirebaseMcpServer {
   server: Server;
   activeFeatures?: ServerFeature[];
   detectedFeatures?: ServerFeature[];
+  enabledTools?: string[];
   clientInfo?: { name?: string; version?: string };
   emulatorHubClient?: EmulatorHubClient;
   private cliCommand?: string;
@@ -99,9 +100,14 @@ export class FirebaseMcpServer {
     return trackGA4(event, { ...params, ...clientInfoParams });
   }
 
-  constructor(options: { activeFeatures?: ServerFeature[]; projectRoot?: string }) {
+  constructor(options: {
+    activeFeatures?: ServerFeature[];
+    projectRoot?: string;
+    enabledTools?: string[];
+  }) {
     this.activeFeatures = options.activeFeatures;
     this.startupRoot = options.projectRoot || process.env.PROJECT_ROOT;
+    this.enabledTools = options.enabledTools;
     this.server = new Server({ name: "firebase", version: SERVER_VERSION });
     this.server.registerCapabilities({
       tools: { listChanged: true },
@@ -245,7 +251,7 @@ export class FirebaseMcpServer {
     const projectId = (await this.getProjectId()) || "";
     const accountEmail = await this.getAuthenticatedUser();
     const ctx = this._createMcpContext(projectId, accountEmail);
-    return availableTools(ctx, features);
+    return availableTools(ctx, features, this.enabledTools);
   }
 
   async getTool(name: string): Promise<ServerTool | null> {

src/mcp/tools/index.ts

@@ -1,47 +1,30 @@
 import { ServerTool } from "../tool";
 import { McpContext, ServerFeature } from "../types";
+import { appHostingTools } from "./apphosting/index";
+import { apptestingTools } from "./apptesting/index";
 import { authTools } from "./auth/index";
+import { coreTools } from "./core/index";
+import { crashlyticsTools } from "./crashlytics/index";
 import { dataconnectTools } from "./dataconnect/index";
 import { firestoreTools } from "./firestore/index";
-import { coreTools } from "./core/index";
-import { storageTools } from "./storage/index";
+import { functionsTools } from "./functions/index";
 import { messagingTools } from "./messaging/index";
-import { remoteConfigTools } from "./remoteconfig/index";
-import { crashlyticsTools } from "./crashlytics/index";
-import { appHostingTools } from "./apphosting/index";
-import { apptestingTools } from "./apptesting/index";
 import { realtimeDatabaseTools } from "./realtime_database/index";
-import { functionsTools } from "./functions/index";
-
-/** availableTools returns the list of MCP tools available given the server flags */
-export async function availableTools(
-  ctx: McpContext,
-  activeFeatures?: ServerFeature[],
-): Promise<ServerTool[]> {
-  const allTools = getAllTools(activeFeatures);
-  const availabilities = await Promise.all(
-    allTools.map((t) => {
-      if (t.isAvailable) {
-        return t.isAvailable(ctx);
-      }
-      return true;
-    }),
-  );
-  return allTools.filter((_, i) => availabilities[i]);
-}
+import { remoteConfigTools } from "./remoteconfig/index";
+import { storageTools } from "./storage/index";
 
-function getAllTools(activeFeatures?: ServerFeature[]): ServerTool[] {
-  const toolDefs: ServerTool[] = [];
-  if (!activeFeatures?.length) {
-    activeFeatures = Object.keys(tools) as ServerFeature[];
-  }
-  if (!activeFeatures.includes("core")) {
-    activeFeatures.unshift("core");
-  }
-  for (const key of activeFeatures) {
-    toolDefs.push(...tools[key]);
-  }
-  return toolDefs;
+function addFeaturePrefix(feature: string, tools: ServerTool[]): ServerTool[] {
+  return tools.map((tool) => ({
+    ...tool,
+    mcp: {
+      ...tool.mcp,
+      name: `${feature}_${tool.mcp.name}`,
+      _meta: {
+        ...tool.mcp._meta,
+        feature,
+      },
+    },
+  }));
 }
 
 const tools: Record<ServerFeature, ServerTool[]> = {
@@ -59,26 +42,64 @@ const tools: Record<ServerFeature, ServerTool[]> = {
   database: addFeaturePrefix("realtimedatabase", realtimeDatabaseTools),
 };
 
-function addFeaturePrefix(feature: string, tools: ServerTool[]): ServerTool[] {
-  return tools.map((tool) => ({
-    ...tool,
-    mcp: {
-      ...tool.mcp,
-      name: `${feature}_${tool.mcp.name}`,
-      _meta: {
-        ...tool.mcp._meta,
-        feature,
-      },
-    },
-  }));
+function getToolsByName(names: string[]): ServerTool[] {
+  const allToolsMap = new Map(
+    Object.values(tools)
+      .flat()
+      .map((t) => [t.mcp.name, t]),
+  );
+  const selectedTools = new Set<ServerTool>();
+
+  for (const toolName of names) {
+    const tool = allToolsMap.get(toolName);
+    if (tool) {
+      selectedTools.add(tool);
+    }
+  }
+  return Array.from(selectedTools);
+}
+
+function getToolsByFeature(serverFeatures?: ServerFeature[]): ServerTool[] {
+  const features = new Set(
+    serverFeatures?.length ? serverFeatures : (Object.keys(tools) as ServerFeature[]),
+  );
+  features.add("core");
+
+  return Array.from(features).flatMap((feature) => tools[feature] || []);
+}
+
+/**
+ * Discover all all available tools. When `activeFeatures` is provided, tool discovery will only
+ * consider those features. When `enabledTools` is provided, discovery is skipped entirely, and
+ * only tools with exactly those names are returned.
+ */
+export async function availableTools(
+  ctx: McpContext,
+  activeFeatures?: ServerFeature[],
+  enabledTools?: string[],
+): Promise<ServerTool[]> {
+  if (enabledTools?.length) {
+    return getToolsByName(enabledTools);
+  }
+
+  const allTools = getToolsByFeature(activeFeatures);
+  const availabilities = await Promise.all(
+    allTools.map((t) => {
+      if (t.isAvailable) {
+        return t.isAvailable(ctx);
+      }
+      return true;
+    }),
+  );
+  return allTools.filter((_, i) => availabilities[i]);
 }
 
 /**
  * Generates a markdown table of all available tools and their descriptions.
  * This is used for generating documentation.
  */
 export function markdownDocsOfTools(): string {
-  const allTools = getAllTools([]);
+  const allTools = getToolsByFeature([]);
   let doc = `
 | Tool Name | Feature Group | Description |
 | --------- | ------------- | ----------- |`;