Merge remote-tracking branch 'origin/main' into telemetry

blva · blva · commit 139c3ee43f19 · 2025-04-23T17:42:28.000+01:00
diff --git a/src/common/atlas/apiClient.ts b/src/common/atlas/apiClient.ts
@@ -1,4 +1,3 @@
-import config from "../../config.js";
 import createClient, { Client, Middleware } from "openapi-fetch";
 import type { FetchOptions } from "openapi-fetch";
 import { AccessToken, ClientCredentials } from "simple-oauth2";
@@ -7,6 +6,7 @@ import { paths, operations } from "./openapi.js";
 import { BaseEvent } from "../../telemetry/types.js";
 import { mongoLogId } from "mongodb-log-writer";
 import logger from "../../logger.js";
+import { packageInfo } from "../../packageInfo.js";
 
 const ATLAS_API_VERSION = "2025-03-12";
 
@@ -71,7 +71,7 @@ export class ApiClient {
             baseUrl: options?.baseUrl || "https://cloud.mongodb.com/",
             userAgent:
                 options?.userAgent ||
-                `${config.mcpServerName}/${config.version} (${process.platform}; ${process.arch}; ${process.env.HOSTNAME || "unknown"})`,
+                `AtlasMCP/${packageInfo.version} (${process.platform}; ${process.arch}; ${process.env.HOSTNAME || "unknown"})`,
         };
 
         this.client = createClient<paths>({
diff --git a/src/config.ts b/src/config.ts
@@ -2,15 +2,11 @@ import path from "path";
 import os from "os";
 import argv from "yargs-parser";
 
-import packageJson from "../package.json" with { type: "json" };
 import { ReadConcernLevel, ReadPreferenceMode, W } from "mongodb";
 
-export const SERVER_NAME = "MdbMcpServer";
-export const SERVER_VERSION = packageJson.version;
-
 // If we decide to support non-string config options, we'll need to extend the mechanism for parsing
 // env variables.
-interface UserConfig {
+export interface UserConfig {
     apiBaseUrl?: string;
     apiClientId?: string;
     apiClientSecret?: string;
@@ -37,20 +33,12 @@ const defaults: UserConfig = {
     disabledTools: [],
 };
 
-const mergedUserConfig = {
+export const config = {
     ...defaults,
     ...getEnvConfig(),
     ...getCliConfig(),
 };
 
-const config = {
-    ...mergedUserConfig,
-    version: SERVER_VERSION,
-    mcpServerName: SERVER_NAME,
-};
-
-export default config;
-
 function getLogPath(): string {
     const localDataPath =
         process.platform === "win32"
diff --git a/src/index.ts b/src/index.ts
@@ -4,20 +4,25 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import logger from "./logger.js";
 import { mongoLogId } from "mongodb-log-writer";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import config from "./config.js";
+import { config } from "./config.js";
 import { Session } from "./session.js";
 import { Server } from "./server.js";
+import { packageInfo } from "./packageInfo.js";
 
 try {
-    const session = new Session();
+    const session = new Session({
+        apiBaseUrl: config.apiBaseUrl,
+        apiClientId: config.apiClientId,
+        apiClientSecret: config.apiClientSecret,
+    });
     const mcpServer = new McpServer({
-        name: "MongoDB Atlas",
-        version: config.version,
+        name: packageInfo.mcpServerName,
+        version: packageInfo.version,
     });
-
     const server = new Server({
         mcpServer,
         session,
+        userConfig: config,
     });
 
     const transport = new StdioServerTransport();
diff --git a/src/logger.ts b/src/logger.ts
@@ -1,6 +1,5 @@
 import fs from "fs/promises";
 import { MongoLogId, MongoLogManager, MongoLogWriter } from "mongodb-log-writer";
-import config from "./config.js";
 import redact from "mongodb-redact";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { LoggingMessageNotification } from "@modelcontextprotocol/sdk/types.js";
@@ -98,11 +97,11 @@ class ProxyingLogger extends LoggerBase {
 const logger = new ProxyingLogger();
 export default logger;
 
-export async function initializeLogger(server: McpServer): Promise<void> {
-    await fs.mkdir(config.logPath, { recursive: true });
+export async function initializeLogger(server: McpServer, logPath: string): Promise<void> {
+    await fs.mkdir(logPath, { recursive: true });
 
     const manager = new MongoLogManager({
-        directory: config.logPath,
+        directory: logPath,
         retentionDays: 30,
         onwarn: console.warn,
         onerror: console.error,
diff --git a/src/packageInfo.ts b/src/packageInfo.ts
@@ -0,0 +1,6 @@
+import packageJson from "../package.json" with { type: "json" };
+
+export const packageInfo = {
+    version: packageJson.version,
+    mcpServerName: "MongoDB MCP Server",
+};
diff --git a/src/server.ts b/src/server.ts
@@ -5,27 +5,35 @@ import { AtlasTools } from "./tools/atlas/tools.js";
 import { MongoDbTools } from "./tools/mongodb/tools.js";
 import logger, { initializeLogger } from "./logger.js";
 import { mongoLogId } from "mongodb-log-writer";
-import config from "./config.js";
 import { ObjectId } from "mongodb";
 import { Telemetry } from "./telemetry/telemetry.js";
+import { UserConfig } from "./config.js";
+
+export interface ServerOptions {
+    session: Session;
+    userConfig: UserConfig;
+    mcpServer: McpServer;
+}
 
 export class Server {
     public readonly session: Session;
     private readonly mcpServer: McpServer;
     private readonly telemetry: Telemetry;
+    private readonly userConfig: UserConfig;
 
-    constructor({ mcpServer, session }: { mcpServer: McpServer; session: Session }) {
-        this.mcpServer = mcpServer;
+    constructor({ session, mcpServer, userConfig }: ServerOptions) {
         this.session = session;
         this.telemetry = new Telemetry(session);
+        this.mcpServer = mcpServer;
+        this.userConfig = userConfig;
     }
 
     async connect(transport: Transport) {
         this.mcpServer.server.registerCapabilities({ logging: {} });
         this.registerTools();
         this.registerResources();
 
-        await initializeLogger(this.mcpServer);
+        await initializeLogger(this.mcpServer, this.userConfig.logPath);
 
         await this.mcpServer.connect(transport);
 
@@ -48,12 +56,12 @@ export class Server {
 
     private registerTools() {
         for (const tool of [...AtlasTools, ...MongoDbTools]) {
-            new tool(this.session, this.telemetry).register(this.mcpServer);
+            new tool(this.session, this.userConfig, this.telemetry).register(this.mcpServer);
         }
     }
 
     private registerResources() {
-        if (config.connectionString) {
+        if (this.userConfig.connectionString) {
             this.mcpServer.resource(
                 "connection-string",
                 "config://connection-string",
@@ -64,7 +72,7 @@ export class Server {
                     return {
                         contents: [
                             {
-                                text: `Preconfigured connection string: ${config.connectionString}`,
+                                text: `Preconfigured connection string: ${this.userConfig.connectionString}`,
                                 uri: uri.href,
                             },
                         ],
diff --git a/src/session.ts b/src/session.ts
@@ -1,7 +1,12 @@
 import { NodeDriverServiceProvider } from "@mongosh/service-provider-node-driver";
 import { ApiClient, ApiClientCredentials } from "./common/atlas/apiClient.js";
 import { Implementation } from "@modelcontextprotocol/sdk/types.js";
-import config from "./config.js";
+
+export interface SessionOptions {
+    apiBaseUrl?: string;
+    apiClientId?: string;
+    apiClientSecret?: string;
+}
 
 export class Session {
     sessionId?: string;
@@ -12,17 +17,17 @@ export class Session {
         version: string;
     };
 
-    constructor() {
+    constructor({ apiBaseUrl, apiClientId, apiClientSecret }: SessionOptions = {}) {
         const credentials: ApiClientCredentials | undefined =
-            config.apiClientId && config.apiClientSecret
+            apiClientId && apiClientSecret
                 ? {
-                      clientId: config.apiClientId,
-                      clientSecret: config.apiClientSecret,
+                      clientId: apiClientId,
+                      clientSecret: apiClientSecret,
                   }
                 : undefined;
 
         this.apiClient = new ApiClient({
-            baseUrl: config.apiBaseUrl,
+            baseUrl: apiBaseUrl,
             credentials,
         });
     }
diff --git a/src/telemetry/constants.ts b/src/telemetry/constants.ts
@@ -1,14 +1,13 @@
-import pkg from "../../package.json" with { type: "json" };
-import config from "../config.js";
 import { getMachineIdSync } from "native-machine-id";
+import { packageInfo } from "../packageInfo.js";
 
 /**
  * Machine-specific metadata formatted for telemetry
  */
 export const MACHINE_METADATA = {
     device_id: getMachineIdSync(),
-    mcp_server_version: pkg.version,
-    mcp_server_name: config.mcpServerName,
+    mcp_server_version: packageInfo.version,
+    mcp_server_name: packageInfo.mcpServerName,
     platform: process.platform,
     arch: process.arch,
     os_type: process.platform,
diff --git a/src/telemetry/telemetry.ts b/src/telemetry/telemetry.ts
@@ -1,6 +1,6 @@
 import { Session } from "../session.js";
 import { BaseEvent } from "./types.js";
-import config from "../config.js";
+import { config } from "../config.js";
 import logger from "../logger.js";
 import { mongoLogId } from "mongodb-log-writer";
 import { ApiClient } from "../common/atlas/apiClient.js";
diff --git a/src/tools/atlas/atlasTool.ts b/src/tools/atlas/atlasTool.ts
@@ -1,20 +1,12 @@
 import { ToolBase, ToolCategory } from "../tool.js";
 import { Session } from "../../session.js";
-import config from "../../config.js";
 import { Telemetry } from "../../telemetry/telemetry.js";
 
 export abstract class AtlasToolBase extends ToolBase {
-    constructor(
-        protected readonly session: Session,
-        telemetry: Telemetry
-    ) {
-        super(session, telemetry);
-    }
-
     protected category: ToolCategory = "atlas";
-
+    
     protected verifyAllowed(): boolean {
-        if (!config.apiClientId || !config.apiClientSecret) {
+        if (!this.config.apiClientId || !this.config.apiClientSecret) {
             return false;
         }
         return super.verifyAllowed();
diff --git a/src/tools/mongodb/metadata/connect.ts b/src/tools/mongodb/metadata/connect.ts
@@ -2,7 +2,6 @@ import { z } from "zod";
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { MongoDBToolBase } from "../mongodbTool.js";
 import { ToolArgs, OperationType } from "../../tool.js";
-import config from "../../../config.js";
 import { MongoError as DriverError } from "mongodb";
 
 export class ConnectTool extends MongoDBToolBase {
@@ -35,7 +34,7 @@ export class ConnectTool extends MongoDBToolBase {
     protected async execute({ options: optionsArr }: ToolArgs<typeof this.argsShape>): Promise<CallToolResult> {
         const options = optionsArr?.[0];
         let connectionString: string;
-        if (!options && !config.connectionString) {
+        if (!options && !this.config.connectionString) {
             return {
                 content: [
                     { type: "text", text: "No connection details provided." },
@@ -46,7 +45,7 @@ export class ConnectTool extends MongoDBToolBase {
 
         if (!options) {
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            connectionString = config.connectionString!;
+            connectionString = this.config.connectionString!;
         } else if ("connectionString" in options) {
             connectionString = options.connectionString;
         } else {
@@ -72,17 +71,17 @@ export class ConnectTool extends MongoDBToolBase {
             // Sometimes the model will supply an incorrect connection string. If the user has configured
             // a different one as environment variable or a cli argument, suggest using that one instead.
             if (
-                config.connectionString &&
+                this.config.connectionString &&
                 error instanceof DriverError &&
-                config.connectionString !== connectionString
+                this.config.connectionString !== connectionString
             ) {
                 return {
                     content: [
                         {
                             type: "text",
                             text:
                                 `Failed to connect to MongoDB at '${connectionString}' due to error: '${error.message}.` +
-                                `Your config lists a different connection string: '${config.connectionString}' - do you want to try connecting to it instead?`,
+                                `Your config lists a different connection string: '${this.config.connectionString}' - do you want to try connecting to it instead?`,
                         },
                     ],
                 };
diff --git a/src/tools/mongodb/mongodbTool.ts b/src/tools/mongodb/mongodbTool.ts
@@ -1,27 +1,20 @@
 import { z } from "zod";
 import { ToolArgs, ToolBase, ToolCategory } from "../tool.js";
-import { Session } from "../../session.js";
 import { NodeDriverServiceProvider } from "@mongosh/service-provider-node-driver";
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { ErrorCodes, MongoDBError } from "../../errors.js";
-import config from "../../config.js";
-import { Telemetry } from "../../telemetry/telemetry.js";
 
 export const DbOperationArgs = {
     database: z.string().describe("Database name"),
     collection: z.string().describe("Collection name"),
 };
 
 export abstract class MongoDBToolBase extends ToolBase {
-    constructor(session: Session, telemetry: Telemetry) {
-        super(session, telemetry);
-    }
-
     protected category: ToolCategory = "mongodb";
 
     protected async ensureConnected(): Promise<NodeDriverServiceProvider> {
-        if (!this.session.serviceProvider && config.connectionString) {
-            await this.connectToMongoDB(config.connectionString);
+        if (!this.session.serviceProvider && this.config.connectionString) {
+            await this.connectToMongoDB(this.config.connectionString);
         }
 
         if (!this.session.serviceProvider) {
@@ -59,13 +52,13 @@ export abstract class MongoDBToolBase extends ToolBase {
             productDocsLink: "https://docs.mongodb.com/todo-mcp",
             productName: "MongoDB MCP",
             readConcern: {
-                level: config.connectOptions.readConcern,
+                level: this.config.connectOptions.readConcern,
             },
-            readPreference: config.connectOptions.readPreference,
+            readPreference: this.config.connectOptions.readPreference,
             writeConcern: {
-                w: config.connectOptions.writeConcern,
+                w: this.config.connectOptions.writeConcern,
             },
-            timeoutMS: config.connectOptions.timeoutMS,
+            timeoutMS: this.config.connectOptions.timeoutMS,
         });
 
         this.session.serviceProvider = provider;
diff --git a/src/tools/tool.ts b/src/tools/tool.ts
diff --git a/tests/integration/helpers.ts b/tests/integration/helpers.ts
diff --git a/tests/integration/server.test.ts b/tests/integration/server.test.ts
diff --git a/tests/integration/tools/mongodb/metadata/connect.test.ts b/tests/integration/tools/mongodb/metadata/connect.test.ts
