feat(mcp): fine grained control over tool loading (#9601)

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

Co-authored-by: Joe Hanley <joehanley@google.com>

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,52 @@ 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.
+  -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;
@@ -53,9 +86,15 @@ export async function mcp(): Promise<void> {
   useFileLogger();
   const activeFeatures = (values.only || "")
     .split(",")
+    .map((f) => f.trim())
     .filter((f) => SERVER_FEATURES.includes(f as ServerFeature)) as ServerFeature[];
+  const enabledTools = (values.tools || "")
+    .split(",")
+    .map((t) => t.trim())
+    .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.spec.ts

@@ -0,0 +1,50 @@
+import { expect } from "chai";
+import { McpContext } from "../types";
+import { availableTools } from "./index";
+
+describe("availableTools", () => {
+  const mockContext: McpContext = {
+    projectId: "test-project",
+    accountEmail: "test@example.com",
+    config: {} as any,
+    host: {
+      logger: {
+        debug: () => void 0,
+        info: () => void 0,
+        warn: () => void 0,
+        error: () => void 0,
+      },
+    } as any,
+    rc: {} as any,
+    firebaseCliCommand: "firebase",
+  };
+
+  it("should return specific tools when enabledTools is provided", async () => {
+    const tools = await availableTools(mockContext, [], ["firebase_login"]);
+
+    expect(tools).to.have.length(1);
+    expect(tools[0].mcp.name).to.equal("firebase_login");
+  });
+
+  it("should return core tools by default", async () => {
+    const tools = await availableTools(mockContext, []);
+    // an example of a core tool
+    const loginTool = tools.find((t) => t.mcp.name === "firebase_login");
+
+    expect(loginTool).to.exist;
+  });
+
+  it("should include feature-specific tools when activeFeatures is provided", async () => {
+    const tools = await availableTools(mockContext, ["firestore"]);
+    const firestoreTool = tools.find((t) => t.mcp.name.startsWith("firestore_"));
+
+    expect(firestoreTool).to.exist;
+  });
+
+  it("should not include feature tools if no active features", async () => {
+    const tools = await availableTools(mockContext, ["core"]);
+    const firestoreTool = tools.find((t) => t.mcp.name.startsWith("firestore_"));
+
+    expect(firestoreTool).to.not.exist;
+  });
+});