implement mcp logging

src/mcp/index.ts

@@ -3,9 +3,11 @@
 import {
   CallToolRequest,
   CallToolRequestSchema,
-  CallToolResult,
-  ListToolsRequestSchema,
   ListToolsResult,
+  LoggingLevel,
+  SetLevelRequestSchema,
+  ListToolsRequestSchema,
+  CallToolResult,
 } from "@modelcontextprotocol/sdk/types.js";
 import { checkFeatureActive, mcpError } from "./util.js";
 import { ClientConfig, SERVER_FEATURES, ServerFeature } from "./types.js";
@@ -30,8 +32,19 @@
 
 const cmd = new Command("experimental:mcp").before(requireAuth);
 
+const orderedLogLevels = [
+  "debug",
+  "info",
+  "notice",
+  "warning",
+  "error",
+  "critical",
+  "alert",
+  "emergency",
+] as const;
+
 export class FirebaseMcpServer {
   private _ready: boolean = false;
   private _readyPromises: { resolve: () => void; reject: (err: unknown) => void }[] = [];
   startupRoot?: string;
   cachedProjectRoot?: string;
@@ -41,18 +54,29 @@
   clientInfo?: { name?: string; version?: string };
   emulatorHubClient?: EmulatorHubClient;
 
+  // logging spec:
+  // https://modelcontextprotocol.io/specification/2025-03-26/server/utilities/logging
+  currentLogLevel?: LoggingLevel;
+  // the api of logging from a consumers perspective looks like `server.logger.warn("my warning")`.
+  public readonly logger = Object.fromEntries(
+    orderedLogLevels.map((logLevel) => [
+      logLevel,
+      (message: unknown) => this.log(logLevel, message),
+    ]),
+  ) as Record<LoggingLevel, (message: unknown) => Promise<void>>;
+
   constructor(options: { activeFeatures?: ServerFeature[]; projectRoot?: string }) {
     this.activeFeatures = options.activeFeatures;
     this.startupRoot = options.projectRoot || process.env.PROJECT_ROOT;
     this.server = new Server({ name: "firebase", version: SERVER_VERSION });
-    this.server.registerCapabilities({ tools: { listChanged: true } });
+    this.server.registerCapabilities({ tools: { listChanged: true }, logging: {} });
     this.server.setRequestHandler(ListToolsRequestSchema, this.mcpListTools.bind(this));
     this.server.setRequestHandler(CallToolRequestSchema, this.mcpCallTool.bind(this));
     this.server.oninitialized = async () => {
       const clientInfo = this.server.getClientVersion();
       this.clientInfo = clientInfo;
       if (clientInfo?.name) {
         trackGA4("mcp_client_connected", {
           mcp_client_name: clientInfo.name,
           mcp_client_version: clientInfo.version,
         });
@@ -64,28 +88,34 @@
         this._readyPromises.pop()?.resolve();
       }
     };
+
+    this.server.setRequestHandler(SetLevelRequestSchema, async ({ params }) => {
+      this.currentLogLevel = params.level;
+      return {};
+    });
+
     this.detectProjectRoot();
     this.detectActiveFeatures();
   }
 
   /** 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 });
     });
   }
 
   private get clientConfigKey() {
     return `mcp.clientConfigs.${this.clientInfo?.name || "<unknown-client>"}:${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;
@@ -275,4 +305,24 @@
     const transport = new StdioServerTransport();
     await this.server.connect(transport);
   }
+
+  private async log(level: LoggingLevel, message: unknown) {
+    let data = message;
+
+    // mcp protocol only takes jsons or it errors; for convienence, format
+    // a a string into a json.
+    if (typeof message === "string") {
+      data = { message };
+    }
+
+    if (!this.currentLogLevel) {
+      return;
+    }
+
+    if (orderedLogLevels.indexOf(this.currentLogLevel) > orderedLogLevels.indexOf(level)) {
+      return;
+    }
+
+    await this.server.sendLoggingMessage({ level, data });
+  }
 }