feat: add SSE mode support for MCP server

src/bin/mcp.ts

@@ -49,15 +49,19 @@
                             If specified, auto-detection is disabled for other features.
   --tools <tools>           Comma-separated list of specific tools to enable. Disables
                             auto-detection entirely.
+  --mode <mode>             Server mode: stdio, sse (defaults to stdio).
+  --port <port>             The port to listen on when running in SSE mode (defaults to 3000).
   -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" },
+      mode: { type: "string", default: "stdio" },
+      port: { type: "string", default: "3000" },
       "generate-tool-list": { type: "boolean", default: false },
       "generate-prompt-list": { type: "boolean", default: false },
       "generate-resource-list": { type: "boolean", default: false },
@@ -85,6 +89,11 @@
   }
   if (earlyExit) return;
 
+  if (values.mode !== "stdio" && values.mode !== "sse") {
+    console.error("Error: --mode must be either 'stdio' or 'sse'");
+    process.exit(1);
+  }
+
   setFirebaseMcp(true);
   // Write debug logs to ~/.cache/firebase to avoid polluting the user's project directory.
   const mcpLogDir = join(homedir(), ".cache", "firebase");
@@ -103,6 +112,9 @@
     enabledTools,
     projectRoot: values.dir ? resolve(values.dir) : undefined,
   });
-  await server.start();
+  await server.start({
+    useSSE: values.mode === "sse",
+    port: values.port ? parseInt(values.port, 10) : undefined,
+  });
   if (process.stdin.isTTY) process.stderr.write(STARTUP_MESSAGE);
 }

src/mcp/index.ts

@@ -1,5 +1,8 @@
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import express from "express";
+import cors from "cors";
 import {
   CallToolRequest,
   CallToolRequestSchema,
@@ -154,7 +157,7 @@
   }
 
   /** Wait until initialization has finished. */
   ready() {
     if (this._ready) return Promise.resolve();
     return new Promise((resolve, reject) => {
       this._readyPromises.push({ resolve: resolve as () => void, reject });
@@ -165,19 +168,19 @@
     return this.clientInfo?.name ?? (isFirebaseStudio() ? "Firebase Studio" : "<unknown-client>");
   }
 
   private get clientConfigKey() {
     return `mcp.clientConfigs.${this.clientName}:${this.startupRoot || process.cwd()}`;
   }
 
   getStoredClientConfig(): ClientConfig {
     return configstore.get(this.clientConfigKey) || {};
   }
 
   updateStoredClientConfig(update: Partial<ClientConfig>) {
     const config = configstore.get(this.clientConfigKey) || {};
     const newConfig = { ...config, ...update };
     configstore.set(this.clientConfigKey, newConfig);
     return newConfig;
   }
 
   async detectProjectSetup(): Promise<void> {
@@ -192,13 +195,13 @@
     if (this.cachedProjectDir) return this.cachedProjectDir;
     const storedRoot = this.getStoredClientConfig().projectRoot;
     this.cachedProjectDir = storedRoot || this.startupRoot || process.cwd();
     this.logger.debug(`detected and cached project root: ${this.cachedProjectDir}`);
     return this.cachedProjectDir;
   }
 
   async detectActiveFeatures(): Promise<ServerFeature[]> {
     if (this.detectedFeatures?.length) return this.detectedFeatures; // memoized
     this.logger.debug("detecting active features of Firebase MCP server...");
     const projectId = (await this.getProjectId()) || "";
     const accountEmail = await this.getAuthenticatedUser();
     const isBillingEnabled = projectId ? await this.safeCheckBillingEnabled(projectId) : false;
@@ -381,6 +384,9 @@
 
     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", {
@@ -488,7 +494,71 @@
     return resolved.result;
   }
 
-  async start(): Promise<void> {
+  async start(options?: { useSSE?: boolean; port?: number }): Promise<void> {
+    if (options?.useSSE) {
+      const app = express();
+
+      app.use(cors());
+
+      const port = options.port || 3000;
+      const transports: Record<string, SSEServerTransport> = {}; // session ID to transport
+
+      app.get("/sse", async (req: express.Request, res: express.Response) => {
+        this.logger.debug(`[SSE] GET /sse connection attempt from ${req.ip}`);
+        try {
+          const transport = new SSEServerTransport("/message", res);
+          // SSEServerTransport has sessionId but it might not be in the typings
+          interface SSEServerTransportWithSessionId extends SSEServerTransport {
+            sessionId: string;
+          }
+          const sessionId = (transport as SSEServerTransportWithSessionId).sessionId;
+          transports[sessionId] = transport;
+
+          this.logger.debug(`[SSE] Connected session ${sessionId}`);
+
+          await this.server.connect(transport);
+          this.logger.debug(`[SSE] Server connected to transport`);
+
+          // Keep handler alive
+          await new Promise<void>((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: express.Request, res: express.Response) => {
+        const sessionId = req.query.sessionId as string;
+        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 LoggingStdioServerTransport(process.env.FIREBASE_MCP_DEBUG_LOG)
       : new StdioServerTransport();
@@ -498,12 +568,12 @@
   private async safeCheckBillingEnabled(projectId: string): Promise<boolean> {
     try {
       return await checkBillingEnabled(projectId);
-    } catch (e: any) {
+    } catch (e: unknown) {
       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;
     }

src/mcp/resource.ts

@@ -7,6 +7,7 @@ export interface ServerResource {
     name: string;
     description?: string;
     title?: string;
+    mimeType?: string;
     _meta?: {
       /** Set this on a resource if it *always* requires a signed-in user to work. */
       requiresAuth?: boolean;

src/mcp/types.ts

@@ -32,4 +32,5 @@ export interface McpContext {
   rc: RC;
   firebaseCliCommand: string;
   isBillingEnabled: boolean;
+  progressToken?: string | number;
 }

src/mcp/util.ts

@@ -41,7 +41,8 @@ export function toContent(
   const suffix = options?.contentSuffix || "";
   return {
     content: [{ type: "text", text: `${prefix}${text}${suffix}` }],
-  };
+    structuredContent: data,
+  } as CallToolResult & { structuredContent: any };
 }
 
 /**