mongodb-mcp-server 0.2.0 → 0.3.0

package/src/common/config.ts

@@ -1,137 +0,0 @@
-import path from "path";
-import os from "os";
-import argv from "yargs-parser";
-
-import { ReadConcernLevel, ReadPreferenceMode, W } from "mongodb";
-
-export interface ConnectOptions {
-    readConcern: ReadConcernLevel;
-    readPreference: ReadPreferenceMode;
-    writeConcern: W;
-    timeoutMS: number;
-}
-
-// If we decide to support non-string config options, we'll need to extend the mechanism for parsing
-// env variables.
-export interface UserConfig {
-    apiBaseUrl: string;
-    apiClientId?: string;
-    apiClientSecret?: string;
-    telemetry: "enabled" | "disabled";
-    logPath: string;
-    connectionString?: string;
-    connectOptions: ConnectOptions;
-    disabledTools: Array<string>;
-    readOnly?: boolean;
-    indexCheck?: boolean;
-    transport: "stdio" | "http";
-    httpPort: number;
-    httpHost: string;
-    loggers: Array<"stderr" | "disk" | "mcp">;
-    idleTimeoutMs: number;
-    notificationTimeoutMs: number;
-}
-
-const defaults: UserConfig = {
-    apiBaseUrl: "https://cloud.mongodb.com/",
-    logPath: getLogPath(),
-    connectOptions: {
-        readConcern: "local",
-        readPreference: "secondaryPreferred",
-        writeConcern: "majority",
-        timeoutMS: 30_000,
-    },
-    disabledTools: [],
-    telemetry: "enabled",
-    readOnly: false,
-    indexCheck: false,
-    transport: "stdio",
-    httpPort: 3000,
-    httpHost: "127.0.0.1",
-    loggers: ["disk", "mcp"],
-    idleTimeoutMs: 600000, // 10 minutes
-    notificationTimeoutMs: 540000, // 9 minutes
-};
-
-export const config = {
-    ...defaults,
-    ...getEnvConfig(),
-    ...getCliConfig(),
-};
-
-function getLogPath(): string {
-    const localDataPath =
-        process.platform === "win32"
-            ? path.join(process.env.LOCALAPPDATA || process.env.APPDATA || os.homedir(), "mongodb")
-            : path.join(os.homedir(), ".mongodb");
-
-    const logPath = path.join(localDataPath, "mongodb-mcp", ".app-logs");
-
-    return logPath;
-}
-
-// Gets the config supplied by the user as environment variables. The variable names
-// are prefixed with `MDB_MCP_` and the keys match the UserConfig keys, but are converted
-// to SNAKE_UPPER_CASE.
-function getEnvConfig(): Partial<UserConfig> {
-    function setValue(obj: Record<string, unknown>, path: string[], value: string): void {
-        const currentField = path.shift();
-        if (!currentField) {
-            return;
-        }
-        if (path.length === 0) {
-            const numberValue = Number(value);
-            if (!isNaN(numberValue)) {
-                obj[currentField] = numberValue;
-                return;
-            }
-
-            const booleanValue = value.toLocaleLowerCase();
-            if (booleanValue === "true" || booleanValue === "false") {
-                obj[currentField] = booleanValue === "true";
-                return;
-            }
-
-            // Try to parse an array of values
-            if (value.indexOf(",") !== -1) {
-                obj[currentField] = value.split(",").map((v) => v.trim());
-                return;
-            }
-
-            obj[currentField] = value;
-            return;
-        }
-
-        if (!obj[currentField]) {
-            obj[currentField] = {};
-        }
-
-        setValue(obj[currentField] as Record<string, unknown>, path, value);
-    }
-
-    const result: Record<string, unknown> = {};
-    const mcpVariables = Object.entries(process.env).filter(
-        ([key, value]) => value !== undefined && key.startsWith("MDB_MCP_")
-    ) as [string, string][];
-    for (const [key, value] of mcpVariables) {
-        const fieldPath = key
-            .replace("MDB_MCP_", "")
-            .split(".")
-            .map((part) => SNAKE_CASE_toCamelCase(part));
-
-        setValue(result, fieldPath, value);
-    }
-
-    return result;
-}
-
-function SNAKE_CASE_toCamelCase(str: string): string {
-    return str.toLowerCase().replace(/([-_][a-z])/g, (group) => group.toUpperCase().replace("_", ""));
-}
-
-// Reads the cli args and parses them into a UserConfig object.
-function getCliConfig() {
-    return argv(process.argv.slice(2), {
-        array: ["disabledTools", "loggers"],
-    }) as unknown as Partial<UserConfig>;
-}

package/src/common/errors.ts

@@ -1,14 +0,0 @@
-export enum ErrorCodes {
-    NotConnectedToMongoDB = 1_000_000,
-    MisconfiguredConnectionString = 1_000_001,
-    ForbiddenCollscan = 1_000_002,
-}
-
-export class MongoDBError extends Error {
-    constructor(
-        public code: ErrorCodes,
-        message: string
-    ) {
-        super(message);
-    }
-}

package/src/common/logger.ts

@@ -1,188 +0,0 @@
-import fs from "fs/promises";
-import { mongoLogId, MongoLogId, MongoLogManager, MongoLogWriter } from "mongodb-log-writer";
-import redact from "mongodb-redact";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { LoggingMessageNotification } from "@modelcontextprotocol/sdk/types.js";
-
-export type LogLevel = LoggingMessageNotification["params"]["level"];
-
-export const LogId = {
-    serverStartFailure: mongoLogId(1_000_001),
-    serverInitialized: mongoLogId(1_000_002),
-    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),
-    telemetryEmitStart: mongoLogId(1_002_003),
-    telemetryEmitSuccess: mongoLogId(1_002_004),
-    telemetryMetadataError: mongoLogId(1_002_005),
-    telemetryDeviceIdFailure: mongoLogId(1_002_006),
-    telemetryDeviceIdTimeout: mongoLogId(1_002_007),
-
-    toolExecute: mongoLogId(1_003_001),
-    toolExecuteFailure: mongoLogId(1_003_002),
-    toolDisabled: mongoLogId(1_003_003),
-
-    mongodbConnectFailure: mongoLogId(1_004_001),
-    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;
-
-export abstract class LoggerBase {
-    abstract log(level: LogLevel, id: MongoLogId, context: string, message: string): void;
-
-    info(id: MongoLogId, context: string, message: string): void {
-        this.log("info", id, context, message);
-    }
-
-    error(id: MongoLogId, context: string, message: string): void {
-        this.log("error", id, context, message);
-    }
-    debug(id: MongoLogId, context: string, message: string): void {
-        this.log("debug", id, context, message);
-    }
-
-    notice(id: MongoLogId, context: string, message: string): void {
-        this.log("notice", id, context, message);
-    }
-
-    warning(id: MongoLogId, context: string, message: string): void {
-        this.log("warning", id, context, message);
-    }
-
-    critical(id: MongoLogId, context: string, message: string): void {
-        this.log("critical", id, context, message);
-    }
-
-    alert(id: MongoLogId, context: string, message: string): void {
-        this.log("alert", id, context, message);
-    }
-
-    emergency(id: MongoLogId, context: string, message: string): void {
-        this.log("emergency", id, context, message);
-    }
-}
-
-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} (${process.pid})`);
-    }
-}
-
-export class DiskLogger extends LoggerBase {
-    private constructor(private logWriter: MongoLogWriter) {
-        super();
-    }
-
-    static async fromPath(logPath: string): Promise<DiskLogger> {
-        await fs.mkdir(logPath, { recursive: true });
-
-        const manager = new MongoLogManager({
-            directory: logPath,
-            retentionDays: 30,
-            onwarn: console.warn,
-            onerror: console.error,
-            gzip: false,
-            retentionGB: 1,
-        });
-
-        await manager.cleanupOldLogFiles();
-
-        const logWriter = await manager.createLogWriter();
-
-        return new DiskLogger(logWriter);
-    }
-
-    log(level: LogLevel, id: MongoLogId, context: string, message: string): void {
-        message = redact(message);
-        const mongoDBLevel = this.mapToMongoDBLogLevel(level);
-
-        this.logWriter[mongoDBLevel]("MONGODB-MCP", id, context, message);
-    }
-
-    private mapToMongoDBLogLevel(level: LogLevel): "info" | "warn" | "error" | "debug" | "fatal" {
-        switch (level) {
-            case "info":
-                return "info";
-            case "warning":
-                return "warn";
-            case "error":
-                return "error";
-            case "notice":
-            case "debug":
-                return "debug";
-            case "critical":
-            case "alert":
-            case "emergency":
-                return "fatal";
-            default:
-                return "info";
-        }
-    }
-}
-
-export class McpLogger extends LoggerBase {
-    constructor(private server: McpServer) {
-        super();
-    }
-
-    log(level: LogLevel, _: MongoLogId, context: string, message: string): void {
-        // Only log if the server is connected
-        if (!this.server?.isConnected()) {
-            return;
-        }
-
-        void this.server.server.sendLoggingMessage({
-            level,
-            data: `[${context}]: ${message}`,
-        });
-    }
-}
-
-class CompositeLogger extends LoggerBase {
-    private loggers: LoggerBase[] = [];
-
-    constructor(...loggers: LoggerBase[]) {
-        super();
-
-        this.setLoggers(...loggers);
-    }
-
-    setLoggers(...loggers: LoggerBase[]): void {
-        if (loggers.length === 0) {
-            throw new Error("At least one logger must be provided");
-        }
-        this.loggers = [...loggers];
-    }
-
-    log(level: LogLevel, id: MongoLogId, context: string, message: string): void {
-        for (const logger of this.loggers) {
-            logger.log(level, id, context, message);
-        }
-    }
-}
-
-const logger = new CompositeLogger(new ConsoleLogger());
-export default logger;

package/src/common/managedTimeout.ts

@@ -1,27 +0,0 @@
-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/common/packageInfo.ts

@@ -1,6 +0,0 @@
-import packageJson from "../../package.json" with { type: "json" };
-
-export const packageInfo = {
-    version: packageJson.version,
-    mcpServerName: "MongoDB MCP Server",
-};

package/src/common/session.ts

@@ -1,118 +0,0 @@
-import { NodeDriverServiceProvider } from "@mongosh/service-provider-node-driver";
-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 "./packageInfo.js";
-
-export interface SessionOptions {
-    apiBaseUrl: string;
-    apiClientId?: string;
-    apiClientSecret?: string;
-}
-
-export class Session extends EventEmitter<{
-    close: [];
-    disconnect: [];
-}> {
-    sessionId?: string;
-    serviceProvider?: NodeDriverServiceProvider;
-    apiClient: ApiClient;
-    agentRunner?: {
-        name: string;
-        version: string;
-    };
-    connectedAtlasCluster?: {
-        username: string;
-        projectId: string;
-        clusterName: string;
-        expiryDate: Date;
-    };
-
-    constructor({ apiBaseUrl, apiClientId, apiClientSecret }: SessionOptions) {
-        super();
-
-        const credentials: ApiClientCredentials | undefined =
-            apiClientId && apiClientSecret
-                ? {
-                      clientId: apiClientId,
-                      clientSecret: apiClientSecret,
-                  }
-                : undefined;
-
-        this.apiClient = new ApiClient({
-            baseUrl: apiBaseUrl,
-            credentials,
-        });
-    }
-
-    setAgentRunner(agentRunner: Implementation | undefined) {
-        if (agentRunner?.name && agentRunner?.version) {
-            this.agentRunner = {
-                name: agentRunner.name,
-                version: agentRunner.version,
-            };
-        }
-    }
-
-    async disconnect(): Promise<void> {
-        if (this.serviceProvider) {
-            try {
-                await this.serviceProvider.close(true);
-            } catch (err: unknown) {
-                const error = err instanceof Error ? err : new Error(String(err));
-                logger.error(LogId.mongodbDisconnectFailure, "Error closing service provider:", error.message);
-            }
-            this.serviceProvider = undefined;
-        }
-        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;
-        }
-        this.emit("disconnect");
-    }
-
-    async close(): Promise<void> {
-        await this.disconnect();
-        await this.apiClient.close();
-        this.emit("close");
-    }
-
-    async connectToMongoDB(connectionString: string, connectOptions: ConnectOptions): Promise<void> {
-        connectionString = setAppNameParamIfMissing({
-            connectionString,
-            defaultAppName: `${packageInfo.mcpServerName} ${packageInfo.version}`,
-        });
-        this.serviceProvider = await NodeDriverServiceProvider.connect(connectionString, {
-            productDocsLink: "https://github.com/mongodb-js/mongodb-mcp-server/",
-            productName: "MongoDB MCP",
-            readConcern: {
-                level: connectOptions.readConcern,
-            },
-            readPreference: connectOptions.readPreference,
-            writeConcern: {
-                w: connectOptions.writeConcern,
-            },
-            timeoutMS: connectOptions.timeoutMS,
-        });
-    }
-}

package/src/common/sessionStore.ts

@@ -1,111 +0,0 @@
-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/connectionOptions.ts

@@ -1,20 +0,0 @@
-import { MongoClientOptions } from "mongodb";
-import ConnectionString from "mongodb-connection-string-url";
-
-export function setAppNameParamIfMissing({
-    connectionString,
-    defaultAppName,
-}: {
-    connectionString: string;
-    defaultAppName?: string;
-}): string {
-    const connectionStringUrl = new ConnectionString(connectionString);
-
-    const searchParams = connectionStringUrl.typedSearchParams<MongoClientOptions>();
-
-    if (!searchParams.has("appName") && defaultAppName !== undefined) {
-        searchParams.set("appName", defaultAppName);
-    }
-
-    return connectionStringUrl.toString();
-}

package/src/helpers/container.ts

@@ -1,35 +0,0 @@
-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/generatePassword.ts

@@ -1,10 +0,0 @@
-import { randomBytes } from "crypto";
-import { promisify } from "util";
-
-const randomBytesAsync = promisify(randomBytes);
-
-export async function generateSecurePassword(): Promise<string> {
-    const buf = await randomBytesAsync(16);
-    const pass = buf.toString("base64url");
-    return pass;
-}