mongodb-mcp-server 0.1.2 → 0.2.0

package/src/{logger.ts → common/logger.ts}

@@ -12,11 +12,17 @@ export const LogId = {
     serverCloseRequested: mongoLogId(1_000_003),
     serverClosed: mongoLogId(1_000_004),
     serverCloseFailure: mongoLogId(1_000_005),
+    serverDuplicateLoggers: mongoLogId(1_000_006),
 
     atlasCheckCredentials: mongoLogId(1_001_001),
     atlasDeleteDatabaseUserFailure: mongoLogId(1_001_002),
     atlasConnectFailure: mongoLogId(1_001_003),
     atlasInspectFailure: mongoLogId(1_001_004),
+    atlasConnectAttempt: mongoLogId(1_001_005),
+    atlasConnectSucceeded: mongoLogId(1_001_006),
+    atlasApiRevokeFailure: mongoLogId(1_001_007),
+    atlasIpAccessListAdded: mongoLogId(1_001_008),
+    atlasIpAccessListAddFailure: mongoLogId(1_001_009),
 
     telemetryDisabled: mongoLogId(1_002_001),
     telemetryEmitFailure: mongoLogId(1_002_002),
@@ -25,7 +31,6 @@ export const LogId = {
     telemetryMetadataError: mongoLogId(1_002_005),
     telemetryDeviceIdFailure: mongoLogId(1_002_006),
     telemetryDeviceIdTimeout: mongoLogId(1_002_007),
-    telemetryContainerEnvFailure: mongoLogId(1_002_008),
 
     toolExecute: mongoLogId(1_003_001),
     toolExecuteFailure: mongoLogId(1_003_002),
@@ -35,9 +40,16 @@ export const LogId = {
     mongodbDisconnectFailure: mongoLogId(1_004_002),
 
     toolUpdateFailure: mongoLogId(1_005_001),
+
+    streamableHttpTransportStarted: mongoLogId(1_006_001),
+    streamableHttpTransportSessionCloseFailure: mongoLogId(1_006_002),
+    streamableHttpTransportSessionCloseNotification: mongoLogId(1_006_003),
+    streamableHttpTransportSessionCloseNotificationFailure: mongoLogId(1_006_004),
+    streamableHttpTransportRequestFailure: mongoLogId(1_006_005),
+    streamableHttpTransportCloseFailure: mongoLogId(1_006_006),
 } as const;
 
-abstract class LoggerBase {
+export abstract class LoggerBase {
     abstract log(level: LogLevel, id: MongoLogId, context: string, message: string): void;
 
     info(id: MongoLogId, context: string, message: string): void {
@@ -72,14 +84,14 @@ abstract class LoggerBase {
     }
 }
 
-class ConsoleLogger extends LoggerBase {
+export class ConsoleLogger extends LoggerBase {
     log(level: LogLevel, id: MongoLogId, context: string, message: string): void {
         message = redact(message);
-        console.error(`[${level.toUpperCase()}] ${id.__value} - ${context}: ${message}`);
+        console.error(`[${level.toUpperCase()}] ${id.__value} - ${context}: ${message} (${process.pid})`);
     }
 }
 
-class DiskLogger extends LoggerBase {
+export class DiskLogger extends LoggerBase {
     private constructor(private logWriter: MongoLogWriter) {
         super();
     }
@@ -131,7 +143,7 @@ class DiskLogger extends LoggerBase {
     }
 }
 
-class McpLogger extends LoggerBase {
+export class McpLogger extends LoggerBase {
     constructor(private server: McpServer) {
         super();
     }
@@ -150,18 +162,12 @@ class McpLogger extends LoggerBase {
 }
 
 class CompositeLogger extends LoggerBase {
-    private loggers: LoggerBase[];
+    private loggers: LoggerBase[] = [];
 
     constructor(...loggers: LoggerBase[]) {
         super();
 
-        if (loggers.length === 0) {
-            // default to ConsoleLogger
-            this.loggers = [new ConsoleLogger()];
-            return;
-        }
-
-        this.loggers = [...loggers];
+        this.setLoggers(...loggers);
     }
 
     setLoggers(...loggers: LoggerBase[]): void {
@@ -178,14 +184,5 @@ class CompositeLogger extends LoggerBase {
     }
 }
 
-const logger = new CompositeLogger();
+const logger = new CompositeLogger(new ConsoleLogger());
 export default logger;
-
-export async function initializeLogger(server: McpServer, logPath: string): Promise<LoggerBase> {
-    const diskLogger = await DiskLogger.fromPath(logPath);
-    const mcpLogger = new McpLogger(server);
-
-    logger.setLoggers(mcpLogger, diskLogger);
-
-    return logger;
-}

package/src/common/managedTimeout.ts

@@ -0,0 +1,27 @@
+export interface ManagedTimeout {
+    cancel: () => void;
+    restart: () => void;
+}
+
+export function setManagedTimeout(callback: () => Promise<void> | void, timeoutMS: number): ManagedTimeout {
+    let timeoutId: NodeJS.Timeout | undefined = setTimeout(() => {
+        void callback();
+    }, timeoutMS);
+
+    function cancel() {
+        clearTimeout(timeoutId);
+        timeoutId = undefined;
+    }
+
+    function restart() {
+        cancel();
+        timeoutId = setTimeout(() => {
+            void callback();
+        }, timeoutMS);
+    }
+
+    return {
+        cancel,
+        restart,
+    };
+}

package/src/{session.ts → common/session.ts}

@@ -1,11 +1,11 @@
 import { NodeDriverServiceProvider } from "@mongosh/service-provider-node-driver";
-import { ApiClient, ApiClientCredentials } from "./common/atlas/apiClient.js";
+import { ApiClient, ApiClientCredentials } from "./atlas/apiClient.js";
 import { Implementation } from "@modelcontextprotocol/sdk/types.js";
 import logger, { LogId } from "./logger.js";
 import EventEmitter from "events";
 import { ConnectOptions } from "./config.js";
-import { setAppNameParamIfMissing } from "./helpers/connectionOptions.js";
-import { packageInfo } from "./helpers/packageInfo.js";
+import { setAppNameParamIfMissing } from "../helpers/connectionOptions.js";
+import { packageInfo } from "./packageInfo.js";
 
 export interface SessionOptions {
     apiBaseUrl: string;
@@ -67,35 +67,33 @@ export class Session extends EventEmitter<{
             }
             this.serviceProvider = undefined;
         }
-        if (!this.connectedAtlasCluster) {
-            this.emit("disconnect");
-            return;
-        }
-        void this.apiClient
-            .deleteDatabaseUser({
-                params: {
-                    path: {
-                        groupId: this.connectedAtlasCluster.projectId,
-                        username: this.connectedAtlasCluster.username,
-                        databaseName: "admin",
+        if (this.connectedAtlasCluster?.username && this.connectedAtlasCluster?.projectId) {
+            void this.apiClient
+                .deleteDatabaseUser({
+                    params: {
+                        path: {
+                            groupId: this.connectedAtlasCluster.projectId,
+                            username: this.connectedAtlasCluster.username,
+                            databaseName: "admin",
+                        },
                     },
-                },
-            })
-            .catch((err: unknown) => {
-                const error = err instanceof Error ? err : new Error(String(err));
-                logger.error(
-                    LogId.atlasDeleteDatabaseUserFailure,
-                    "atlas-connect-cluster",
-                    `Error deleting previous database user: ${error.message}`
-                );
-            });
-        this.connectedAtlasCluster = undefined;
-
+                })
+                .catch((err: unknown) => {
+                    const error = err instanceof Error ? err : new Error(String(err));
+                    logger.error(
+                        LogId.atlasDeleteDatabaseUserFailure,
+                        "atlas-connect-cluster",
+                        `Error deleting previous database user: ${error.message}`
+                    );
+                });
+            this.connectedAtlasCluster = undefined;
+        }
         this.emit("disconnect");
     }
 
     async close(): Promise<void> {
         await this.disconnect();
+        await this.apiClient.close();
         this.emit("close");
     }
 

package/src/common/sessionStore.ts

@@ -0,0 +1,111 @@
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import logger, { LogId, LoggerBase, McpLogger } from "./logger.js";
+import { ManagedTimeout, setManagedTimeout } from "./managedTimeout.js";
+
+export class SessionStore {
+    private sessions: {
+        [sessionId: string]: {
+            logger: LoggerBase;
+            transport: StreamableHTTPServerTransport;
+            abortTimeout: ManagedTimeout;
+            notificationTimeout: ManagedTimeout;
+        };
+    } = {};
+
+    constructor(
+        private readonly idleTimeoutMS: number,
+        private readonly notificationTimeoutMS: number
+    ) {
+        if (idleTimeoutMS <= 0) {
+            throw new Error("idleTimeoutMS must be greater than 0");
+        }
+        if (notificationTimeoutMS <= 0) {
+            throw new Error("notificationTimeoutMS must be greater than 0");
+        }
+        if (idleTimeoutMS <= notificationTimeoutMS) {
+            throw new Error("idleTimeoutMS must be greater than notificationTimeoutMS");
+        }
+    }
+
+    getSession(sessionId: string): StreamableHTTPServerTransport | undefined {
+        this.resetTimeout(sessionId);
+        return this.sessions[sessionId]?.transport;
+    }
+
+    private resetTimeout(sessionId: string): void {
+        const session = this.sessions[sessionId];
+        if (!session) {
+            return;
+        }
+
+        session.abortTimeout.restart();
+
+        session.notificationTimeout.restart();
+    }
+
+    private sendNotification(sessionId: string): void {
+        const session = this.sessions[sessionId];
+        if (!session) {
+            logger.warning(
+                LogId.streamableHttpTransportSessionCloseNotificationFailure,
+                "sessionStore",
+                `session ${sessionId} not found, no notification delivered`
+            );
+            return;
+        }
+        session.logger.info(
+            LogId.streamableHttpTransportSessionCloseNotification,
+            "sessionStore",
+            "Session is about to be closed due to inactivity"
+        );
+    }
+
+    setSession(sessionId: string, transport: StreamableHTTPServerTransport, mcpServer: McpServer): void {
+        const session = this.sessions[sessionId];
+        if (session) {
+            throw new Error(`Session ${sessionId} already exists`);
+        }
+        const abortTimeout = setManagedTimeout(async () => {
+            if (this.sessions[sessionId]) {
+                this.sessions[sessionId].logger.info(
+                    LogId.streamableHttpTransportSessionCloseNotification,
+                    "sessionStore",
+                    "Session closed due to inactivity"
+                );
+
+                await this.closeSession(sessionId);
+            }
+        }, this.idleTimeoutMS);
+        const notificationTimeout = setManagedTimeout(
+            () => this.sendNotification(sessionId),
+            this.notificationTimeoutMS
+        );
+        this.sessions[sessionId] = { logger: new McpLogger(mcpServer), transport, abortTimeout, notificationTimeout };
+    }
+
+    async closeSession(sessionId: string, closeTransport: boolean = true): Promise<void> {
+        const session = this.sessions[sessionId];
+        if (!session) {
+            throw new Error(`Session ${sessionId} not found`);
+        }
+        session.abortTimeout.cancel();
+        session.notificationTimeout.cancel();
+        if (closeTransport) {
+            try {
+                await session.transport.close();
+            } catch (error) {
+                logger.error(
+                    LogId.streamableHttpTransportSessionCloseFailure,
+                    "streamableHttpTransport",
+                    `Error closing transport ${sessionId}: ${error instanceof Error ? error.message : String(error)}`
+                );
+            }
+        }
+        delete this.sessions[sessionId];
+    }
+
+    async closeAllSessions(): Promise<void> {
+        await Promise.all(Object.keys(this.sessions).map((sessionId) => this.closeSession(sessionId)));
+    }
+}

package/src/helpers/container.ts

@@ -0,0 +1,35 @@
+import fs from "fs/promises";
+
+let containerEnv: boolean | undefined;
+
+export async function detectContainerEnv(): Promise<boolean> {
+    if (containerEnv !== undefined) {
+        return containerEnv;
+    }
+
+    const detect = async function (): Promise<boolean> {
+        if (process.platform !== "linux") {
+            return false; // we only support linux containers for now
+        }
+
+        if (process.env.container) {
+            return true;
+        }
+
+        const exists = await Promise.all(
+            ["/.dockerenv", "/run/.containerenv", "/var/run/.containerenv"].map(async (file) => {
+                try {
+                    await fs.access(file);
+                    return true;
+                } catch {
+                    return false;
+                }
+            })
+        );
+
+        return exists.includes(true);
+    };
+
+    containerEnv = await detect();
+    return containerEnv;
+}

package/src/helpers/indexCheck.ts

@@ -0,0 +1,83 @@
+import { Document } from "mongodb";
+import { NodeDriverServiceProvider } from "@mongosh/service-provider-node-driver";
+import { ErrorCodes, MongoDBError } from "../common/errors.js";
+
+/**
+ * Check if the query plan uses an index
+ * @param explainResult The result of the explain query
+ * @returns true if an index is used, false if it's a full collection scan
+ */
+export function usesIndex(explainResult: Document): boolean {
+    const queryPlanner = explainResult?.queryPlanner as Document | undefined;
+    const winningPlan = queryPlanner?.winningPlan as Document | undefined;
+    const stage = winningPlan?.stage as string | undefined;
+    const inputStage = winningPlan?.inputStage as Document | undefined;
+
+    // Check for index scan stages (including MongoDB 8.0+ stages)
+    const indexScanStages = [
+        "IXSCAN",
+        "COUNT_SCAN",
+        "EXPRESS_IXSCAN",
+        "EXPRESS_CLUSTERED_IXSCAN",
+        "EXPRESS_UPDATE",
+        "EXPRESS_DELETE",
+        "IDHACK",
+    ];
+
+    if (stage && indexScanStages.includes(stage)) {
+        return true;
+    }
+
+    if (inputStage && inputStage.stage && indexScanStages.includes(inputStage.stage as string)) {
+        return true;
+    }
+
+    // Recursively check deeper stages
+    if (inputStage && inputStage.inputStage) {
+        return usesIndex({ queryPlanner: { winningPlan: inputStage } });
+    }
+
+    if (stage === "COLLSCAN") {
+        return false;
+    }
+
+    // Default to false (conservative approach)
+    return false;
+}
+
+/**
+ * Generate an error message for index check failure
+ */
+export function getIndexCheckErrorMessage(database: string, collection: string, operation: string): string {
+    return `Index check failed: The ${operation} operation on "${database}.${collection}" performs a collection scan (COLLSCAN) instead of using an index. Consider adding an index for better performance. Use 'explain' tool for query plan analysis or 'collection-indexes' to view existing indexes. To disable this check, set MDB_MCP_INDEX_CHECK to false.`;
+}
+
+/**
+ * Generic function to perform index usage check
+ */
+export async function checkIndexUsage(
+    provider: NodeDriverServiceProvider,
+    database: string,
+    collection: string,
+    operation: string,
+    explainCallback: () => Promise<Document>
+): Promise<void> {
+    try {
+        const explainResult = await explainCallback();
+
+        if (!usesIndex(explainResult)) {
+            throw new MongoDBError(
+                ErrorCodes.ForbiddenCollscan,
+                getIndexCheckErrorMessage(database, collection, operation)
+            );
+        }
+    } catch (error) {
+        if (error instanceof MongoDBError && error.code === ErrorCodes.ForbiddenCollscan) {
+            throw error;
+        }
+
+        // If explain itself fails, log but do not prevent query execution
+        // This avoids blocking normal queries in special cases (e.g., permission issues)
+        console.warn(`Index check failed to execute explain for ${operation} on ${database}.${collection}:`, error);
+    }
+}

package/src/index.ts

@@ -1,58 +1,48 @@
 #!/usr/bin/env node
 
-import logger, { LogId } from "./logger.js";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { config } from "./config.js";
-import { Session } from "./session.js";
-import { Server } from "./server.js";
-import { packageInfo } from "./helpers/packageInfo.js";
-import { Telemetry } from "./telemetry/telemetry.js";
-import { createEJsonTransport } from "./helpers/EJsonTransport.js";
+import logger, { LogId } from "./common/logger.js";
+import { config } from "./common/config.js";
+import { StdioRunner } from "./transports/stdio.js";
+import { StreamableHttpRunner } from "./transports/streamableHttp.js";
 
-try {
-    const session = new Session({
-        apiBaseUrl: config.apiBaseUrl,
-        apiClientId: config.apiClientId,
-        apiClientSecret: config.apiClientSecret,
-    });
-    const mcpServer = new McpServer({
-        name: packageInfo.mcpServerName,
-        version: packageInfo.version,
-    });
-
-    const telemetry = Telemetry.create(session, config);
-
-    const server = new Server({
-        mcpServer,
-        session,
-        telemetry,
-        userConfig: config,
-    });
-
-    const transport = createEJsonTransport();
+async function main() {
+    const transportRunner = config.transport === "stdio" ? new StdioRunner(config) : new StreamableHttpRunner(config);
 
     const shutdown = () => {
         logger.info(LogId.serverCloseRequested, "server", `Server close requested`);
 
-        server
+        transportRunner
             .close()
             .then(() => {
-                logger.info(LogId.serverClosed, "server", `Server closed successfully`);
+                logger.info(LogId.serverClosed, "server", `Server closed`);
                 process.exit(0);
             })
-            .catch((err: unknown) => {
-                const error = err instanceof Error ? err : new Error(String(err));
-                logger.error(LogId.serverCloseFailure, "server", `Error closing server: ${error.message}`);
+            .catch((error: unknown) => {
+                logger.error(LogId.serverCloseFailure, "server", `Error closing server: ${error as string}`);
                 process.exit(1);
             });
     };
 
-    process.once("SIGINT", shutdown);
-    process.once("SIGTERM", shutdown);
-    process.once("SIGQUIT", shutdown);
+    process.on("SIGINT", shutdown);
+    process.on("SIGABRT", shutdown);
+    process.on("SIGTERM", shutdown);
+    process.on("SIGQUIT", shutdown);
+
+    try {
+        await transportRunner.start();
+    } catch (error: unknown) {
+        logger.info(LogId.serverCloseRequested, "server", "Closing server");
+        try {
+            await transportRunner.close();
+            logger.info(LogId.serverClosed, "server", "Server closed");
+        } catch (error: unknown) {
+            logger.error(LogId.serverCloseFailure, "server", `Error closing server: ${error as string}`);
+        }
+        throw error;
+    }
+}
 
-    await server.connect(transport);
-} catch (error: unknown) {
+main().catch((error: unknown) => {
     logger.emergency(LogId.serverStartFailure, "server", `Fatal error running server: ${error as string}`);
     process.exit(1);
-}
+});

package/src/server.ts

@@ -1,16 +1,17 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { Session } from "./session.js";
+import { Session } from "./common/session.js";
 import { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
 import { AtlasTools } from "./tools/atlas/tools.js";
 import { MongoDbTools } from "./tools/mongodb/tools.js";
-import logger, { initializeLogger, LogId } from "./logger.js";
+import logger, { LogId, LoggerBase, McpLogger, DiskLogger, ConsoleLogger } from "./common/logger.js";
 import { ObjectId } from "mongodb";
 import { Telemetry } from "./telemetry/telemetry.js";
-import { UserConfig } from "./config.js";
+import { UserConfig } from "./common/config.js";
 import { type ServerEvent } from "./telemetry/types.js";
 import { type ServerCommand } from "./telemetry/types.js";
 import { CallToolRequestSchema, CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import assert from "assert";
+import { ToolBase } from "./tools/tool.js";
 
 export interface ServerOptions {
     session: Session;
@@ -21,9 +22,10 @@ export interface ServerOptions {
 
 export class Server {
     public readonly session: Session;
-    private readonly mcpServer: McpServer;
+    public readonly mcpServer: McpServer;
     private readonly telemetry: Telemetry;
     public readonly userConfig: UserConfig;
+    public readonly tools: ToolBase[] = [];
     private readonly startTime: number;
 
     constructor({ session, mcpServer, userConfig, telemetry }: ServerOptions) {
@@ -35,6 +37,8 @@ export class Server {
     }
 
     async connect(transport: Transport): Promise<void> {
+        await this.validateConfig();
+
         this.mcpServer.server.registerCapabilities({ logging: {} });
 
         this.registerTools();
@@ -63,9 +67,17 @@ export class Server {
             return existingHandler(request, extra);
         });
 
-        await initializeLogger(this.mcpServer, this.userConfig.logPath);
-
-        await this.mcpServer.connect(transport);
+        const loggers: LoggerBase[] = [];
+        if (this.userConfig.loggers.includes("mcp")) {
+            loggers.push(new McpLogger(this.mcpServer));
+        }
+        if (this.userConfig.loggers.includes("disk")) {
+            loggers.push(await DiskLogger.fromPath(this.userConfig.logPath));
+        }
+        if (this.userConfig.loggers.includes("stderr")) {
+            loggers.push(new ConsoleLogger());
+        }
+        logger.setLoggers(...loggers);
 
         this.mcpServer.server.oninitialized = () => {
             this.session.setAgentRunner(this.mcpServer.server.getClientVersion());
@@ -90,7 +102,7 @@ export class Server {
             this.emitServerEvent("stop", Date.now() - closeTime, error);
         };
 
-        await this.validateConfig();
+        await this.mcpServer.connect(transport);
     }
 
     async close(): Promise<void> {
@@ -130,12 +142,15 @@ export class Server {
             }
         }
 
-        this.telemetry.emitEvents([event]);
+        this.telemetry.emitEvents([event]).catch(() => {});
     }
 
     private registerTools() {
-        for (const tool of [...AtlasTools, ...MongoDbTools]) {
-            new tool(this.session, this.userConfig, this.telemetry).register(this.mcpServer);
+        for (const toolConstructor of [...AtlasTools, ...MongoDbTools]) {
+            const tool = new toolConstructor(this.session, this.userConfig, this.telemetry);
+            if (tool.register(this)) {
+                this.tools.push(tool);
+            }
         }
     }
 
@@ -174,6 +189,35 @@ export class Server {
     }
 
     private async validateConfig(): Promise<void> {
+        const transport = this.userConfig.transport as string;
+        if (transport !== "http" && transport !== "stdio") {
+            throw new Error(`Invalid transport: ${transport}`);
+        }
+
+        const telemetry = this.userConfig.telemetry as string;
+        if (telemetry !== "enabled" && telemetry !== "disabled") {
+            throw new Error(`Invalid telemetry: ${telemetry}`);
+        }
+
+        if (this.userConfig.httpPort < 1 || this.userConfig.httpPort > 65535) {
+            throw new Error(`Invalid httpPort: ${this.userConfig.httpPort}`);
+        }
+
+        if (this.userConfig.loggers.length === 0) {
+            throw new Error("No loggers found in config");
+        }
+
+        const loggerTypes = new Set(this.userConfig.loggers);
+        if (loggerTypes.size !== this.userConfig.loggers.length) {
+            throw new Error("Duplicate loggers found in config");
+        }
+
+        for (const loggerType of this.userConfig.loggers as string[]) {
+            if (loggerType !== "mcp" && loggerType !== "disk" && loggerType !== "stderr") {
+                throw new Error(`Invalid logger: ${loggerType}`);
+            }
+        }
+
         if (this.userConfig.connectionString) {
             try {
                 await this.session.connectToMongoDB(this.userConfig.connectionString, this.userConfig.connectOptions);

package/src/telemetry/constants.ts

@@ -1,4 +1,4 @@
-import { packageInfo } from "../helpers/packageInfo.js";
+import { packageInfo } from "../common/packageInfo.js";
 import { type CommonStaticProperties } from "./types.js";
 
 /**