mongodb-mcp-server 0.1.2 → 0.2.0

package/src/telemetry/telemetry.ts

@@ -1,158 +1,128 @@
-import { Session } from "../session.js";
+import { Session } from "../common/session.js";
 import { BaseEvent, CommonProperties } from "./types.js";
-import { UserConfig } from "../config.js";
-import logger, { LogId } from "../logger.js";
+import { UserConfig } from "../common/config.js";
+import logger, { LogId } from "../common/logger.js";
 import { ApiClient } from "../common/atlas/apiClient.js";
 import { MACHINE_METADATA } from "./constants.js";
 import { EventCache } from "./eventCache.js";
 import nodeMachineId from "node-machine-id";
 import { getDeviceId } from "@mongodb-js/device-id";
-import fs from "fs/promises";
-
-async function fileExists(filePath: string): Promise<boolean> {
-    try {
-        await fs.access(filePath, fs.constants.F_OK);
-        return true; // File exists
-    } catch (e: unknown) {
-        if (
-            e instanceof Error &&
-            (
-                e as Error & {
-                    code: string;
-                }
-            ).code === "ENOENT"
-        ) {
-            return false; // File does not exist
-        }
-        throw e; // Re-throw unexpected errors
-    }
-}
+import { detectContainerEnv } from "../helpers/container.js";
 
-async function isContainerized(): Promise<boolean> {
-    if (process.env.container) {
-        return true;
-    }
-
-    const exists = await Promise.all(["/.dockerenv", "/run/.containerenv", "/var/run/.containerenv"].map(fileExists));
+type EventResult = {
+    success: boolean;
+    error?: Error;
+};
 
-    return exists.includes(true);
-}
+export const DEVICE_ID_TIMEOUT = 3000;
 
 export class Telemetry {
+    private isBufferingEvents: boolean = true;
+    /** Resolves when the setup is complete or a timeout occurs */
+    public setupPromise: Promise<[string, boolean]> | undefined;
     private deviceIdAbortController = new AbortController();
     private eventCache: EventCache;
     private getRawMachineId: () => Promise<string>;
-    private getContainerEnv: () => Promise<boolean>;
-    private cachedCommonProperties?: CommonProperties;
-    private flushing: boolean = false;
 
     private constructor(
         private readonly session: Session,
         private readonly userConfig: UserConfig,
-        {
-            eventCache,
-            getRawMachineId,
-            getContainerEnv,
-        }: {
-            eventCache: EventCache;
-            getRawMachineId: () => Promise<string>;
-            getContainerEnv: () => Promise<boolean>;
-        }
+        private readonly commonProperties: CommonProperties,
+        { eventCache, getRawMachineId }: { eventCache: EventCache; getRawMachineId: () => Promise<string> }
     ) {
         this.eventCache = eventCache;
         this.getRawMachineId = getRawMachineId;
-        this.getContainerEnv = getContainerEnv;
     }
 
     static create(
         session: Session,
         userConfig: UserConfig,
         {
+            commonProperties = { ...MACHINE_METADATA },
             eventCache = EventCache.getInstance(),
             getRawMachineId = () => nodeMachineId.machineId(true),
-            getContainerEnv = isContainerized,
         }: {
             eventCache?: EventCache;
             getRawMachineId?: () => Promise<string>;
-            getContainerEnv?: () => Promise<boolean>;
+            commonProperties?: CommonProperties;
         } = {}
     ): Telemetry {
-        const instance = new Telemetry(session, userConfig, {
-            eventCache,
-            getRawMachineId,
-            getContainerEnv,
-        });
+        const instance = new Telemetry(session, userConfig, commonProperties, { eventCache, getRawMachineId });
 
+        void instance.setup();
         return instance;
     }
 
+    private async setup(): Promise<void> {
+        if (!this.isTelemetryEnabled()) {
+            return;
+        }
+        this.setupPromise = Promise.all([
+            getDeviceId({
+                getMachineId: () => this.getRawMachineId(),
+                onError: (reason, error) => {
+                    switch (reason) {
+                        case "resolutionError":
+                            logger.debug(LogId.telemetryDeviceIdFailure, "telemetry", String(error));
+                            break;
+                        case "timeout":
+                            logger.debug(LogId.telemetryDeviceIdTimeout, "telemetry", "Device ID retrieval timed out");
+                            break;
+                        case "abort":
+                            // No need to log in the case of aborts
+                            break;
+                    }
+                },
+                abortSignal: this.deviceIdAbortController.signal,
+            }),
+            detectContainerEnv(),
+        ]);
+
+        const [deviceId, containerEnv] = await this.setupPromise;
+
+        this.commonProperties.device_id = deviceId;
+        this.commonProperties.is_container_env = containerEnv;
+
+        this.isBufferingEvents = false;
+    }
+
     public async close(): Promise<void> {
         this.deviceIdAbortController.abort();
-        await this.flush();
+        this.isBufferingEvents = false;
+        await this.emitEvents(this.eventCache.getEvents());
     }
 
     /**
      * Emits events through the telemetry pipeline
      * @param events - The events to emit
      */
-    public emitEvents(events: BaseEvent[]): void {
-        void this.flush(events);
+    public async emitEvents(events: BaseEvent[]): Promise<void> {
+        try {
+            if (!this.isTelemetryEnabled()) {
+                logger.info(LogId.telemetryEmitFailure, "telemetry", `Telemetry is disabled.`);
+                return;
+            }
+
+            await this.emit(events);
+        } catch {
+            logger.debug(LogId.telemetryEmitFailure, "telemetry", `Error emitting telemetry events.`);
+        }
     }
 
     /**
      * Gets the common properties for events
      * @returns Object containing common properties for all events
      */
-    private async getCommonProperties(): Promise<CommonProperties> {
-        if (!this.cachedCommonProperties) {
-            let deviceId: string | undefined;
-            let containerEnv: boolean | undefined;
-            try {
-                await Promise.all([
-                    getDeviceId({
-                        getMachineId: () => this.getRawMachineId(),
-                        onError: (reason, error) => {
-                            switch (reason) {
-                                case "resolutionError":
-                                    logger.debug(LogId.telemetryDeviceIdFailure, "telemetry", String(error));
-                                    break;
-                                case "timeout":
-                                    logger.debug(
-                                        LogId.telemetryDeviceIdTimeout,
-                                        "telemetry",
-                                        "Device ID retrieval timed out"
-                                    );
-                                    break;
-                                case "abort":
-                                    // No need to log in the case of aborts
-                                    break;
-                            }
-                        },
-                        abortSignal: this.deviceIdAbortController.signal,
-                    }).then((id) => {
-                        deviceId = id;
-                    }),
-                    this.getContainerEnv().then((env) => {
-                        containerEnv = env;
-                    }),
-                ]);
-            } catch (error: unknown) {
-                const err = error instanceof Error ? error : new Error(String(error));
-                logger.debug(LogId.telemetryDeviceIdFailure, "telemetry", err.message);
-            }
-            this.cachedCommonProperties = {
-                ...MACHINE_METADATA,
-                mcp_client_version: this.session.agentRunner?.version,
-                mcp_client_name: this.session.agentRunner?.name,
-                session_id: this.session.sessionId,
-                config_atlas_auth: this.session.apiClient.hasCredentials() ? "true" : "false",
-                config_connection_string: this.userConfig.connectionString ? "true" : "false",
-                is_container_env: containerEnv ? "true" : "false",
-                device_id: deviceId,
-            };
-        }
-
-        return this.cachedCommonProperties;
+    public getCommonProperties(): CommonProperties {
+        return {
+            ...this.commonProperties,
+            transport: this.userConfig.transport,
+            mcp_client_version: this.session.agentRunner?.version,
+            mcp_client_name: this.session.agentRunner?.name,
+            session_id: this.session.sessionId,
+            config_atlas_auth: this.session.apiClient.hasCredentials() ? "true" : "false",
+            config_connection_string: this.userConfig.connectionString ? "true" : "false",
+        };
     }
 
     /**
@@ -173,74 +143,60 @@ export class Telemetry {
     }
 
     /**
-     * Attempts to flush events through authenticated and unauthenticated clients
+     * Attempts to emit events through authenticated and unauthenticated clients
      * Falls back to caching if both attempts fail
      */
-    public async flush(events?: BaseEvent[]): Promise<void> {
-        if (!this.isTelemetryEnabled()) {
-            logger.info(LogId.telemetryEmitFailure, "telemetry", `Telemetry is disabled.`);
-            return;
-        }
-
-        if (this.flushing) {
-            this.eventCache.appendEvents(events ?? []);
-            process.nextTick(async () => {
-                // try again if in the middle of a flush
-                await this.flush();
-            });
+    private async emit(events: BaseEvent[]): Promise<void> {
+        if (this.isBufferingEvents) {
+            this.eventCache.appendEvents(events);
             return;
         }
 
-        this.flushing = true;
+        const cachedEvents = this.eventCache.getEvents();
+        const allEvents = [...cachedEvents, ...events];
 
-        try {
-            const cachedEvents = this.eventCache.getEvents();
-            const allEvents = [...cachedEvents, ...(events ?? [])];
-            if (allEvents.length <= 0) {
-                this.flushing = false;
-                return;
-            }
-
-            logger.debug(
-                LogId.telemetryEmitStart,
-                "telemetry",
-                `Attempting to send ${allEvents.length} events (${cachedEvents.length} cached)`
-            );
+        logger.debug(
+            LogId.telemetryEmitStart,
+            "telemetry",
+            `Attempting to send ${allEvents.length} events (${cachedEvents.length} cached)`
+        );
 
-            await this.sendEvents(this.session.apiClient, allEvents);
+        const result = await this.sendEvents(this.session.apiClient, allEvents);
+        if (result.success) {
             this.eventCache.clearEvents();
             logger.debug(
                 LogId.telemetryEmitSuccess,
                 "telemetry",
                 `Sent ${allEvents.length} events successfully: ${JSON.stringify(allEvents, null, 2)}`
             );
-        } catch (error: unknown) {
-            logger.debug(
-                LogId.telemetryEmitFailure,
-                "telemetry",
-                `Error sending event to client: ${error instanceof Error ? error.message : String(error)}`
-            );
-            this.eventCache.appendEvents(events ?? []);
-            process.nextTick(async () => {
-                // try again
-                await this.flush();
-            });
+            return;
         }
 
-        this.flushing = false;
+        logger.debug(
+            LogId.telemetryEmitFailure,
+            "telemetry",
+            `Error sending event to client: ${result.error instanceof Error ? result.error.message : String(result.error)}`
+        );
+        this.eventCache.appendEvents(events);
     }
 
     /**
      * Attempts to send events through the provided API client
      */
-    private async sendEvents(client: ApiClient, events: BaseEvent[]): Promise<void> {
-        const commonProperties = await this.getCommonProperties();
-
-        await client.sendEvents(
-            events.map((event) => ({
-                ...event,
-                properties: { ...commonProperties, ...event.properties },
-            }))
-        );
+    private async sendEvents(client: ApiClient, events: BaseEvent[]): Promise<EventResult> {
+        try {
+            await client.sendEvents(
+                events.map((event) => ({
+                    ...event,
+                    properties: { ...this.getCommonProperties(), ...event.properties },
+                }))
+            );
+            return { success: true };
+        } catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error : new Error(String(error)),
+            };
+        }
     }
 }

package/src/telemetry/types.ts

@@ -66,10 +66,11 @@ export type CommonStaticProperties = {
  */
 export type CommonProperties = {
     device_id?: string;
+    is_container_env?: boolean;
     mcp_client_version?: string;
     mcp_client_name?: string;
+    transport?: "stdio" | "http";
     config_atlas_auth?: TelemetryBoolSet;
     config_connection_string?: TelemetryBoolSet;
     session_id?: string;
-    is_container_env?: TelemetryBoolSet;
 } & CommonStaticProperties;

package/src/tools/atlas/atlasTool.ts

@@ -1,12 +1,12 @@
 import { ToolBase, ToolCategory, TelemetryToolMetadata, ToolArgs } from "../tool.js";
 import { ToolCallback } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import logger, { LogId } from "../../logger.js";
+import logger, { LogId } from "../../common/logger.js";
 import { z } from "zod";
 import { ApiClientError } from "../../common/atlas/apiClientError.js";
 
 export abstract class AtlasToolBase extends ToolBase {
-    protected category: ToolCategory = "atlas";
+    public category: ToolCategory = "atlas";
 
     protected verifyAllowed(): boolean {
         if (!this.config.apiClientId || !this.config.apiClientSecret) {
@@ -29,7 +29,7 @@ export abstract class AtlasToolBase extends ToolBase {
                             type: "text",
                             text: `Unable to authenticate with MongoDB Atlas, API error: ${error.message}
 
-Hint: Your API credentials may be invalid, expired or lack permissions. 
+Hint: Your API credentials may be invalid, expired or lack permissions.
 Please check your Atlas API credentials and ensure they have the appropriate permissions.
 For more information on setting up API keys, visit: https://www.mongodb.com/docs/atlas/configure-api-access/`,
                         },
@@ -44,7 +44,7 @@ For more information on setting up API keys, visit: https://www.mongodb.com/docs
                         {
                             type: "text",
                             text: `Received a Forbidden API Error: ${error.message}
-                            
+
 You don't have sufficient permissions to perform this action in MongoDB Atlas
 Please ensure your API key has the necessary roles assigned.
 For more information on Atlas API access roles, visit: https://www.mongodb.com/docs/atlas/api/service-accounts-overview/`,

package/src/tools/atlas/connect/connectCluster.ts

@@ -0,0 +1,259 @@
+import { z } from "zod";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { AtlasToolBase } from "../atlasTool.js";
+import { ToolArgs, OperationType } from "../../tool.js";
+import { generateSecurePassword } from "../../../helpers/generatePassword.js";
+import logger, { LogId } from "../../../common/logger.js";
+import { inspectCluster } from "../../../common/atlas/cluster.js";
+import { ensureCurrentIpInAccessList } from "../../../common/atlas/accessListUtils.js";
+
+const EXPIRY_MS = 1000 * 60 * 60 * 12; // 12 hours
+
+function sleep(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export class ConnectClusterTool extends AtlasToolBase {
+    public name = "atlas-connect-cluster";
+    protected description = "Connect to MongoDB Atlas cluster";
+    public operationType: OperationType = "connect";
+    protected argsShape = {
+        projectId: z.string().describe("Atlas project ID"),
+        clusterName: z.string().describe("Atlas cluster name"),
+    };
+
+    private async queryConnection(
+        projectId: string,
+        clusterName: string
+    ): Promise<"connected" | "disconnected" | "connecting" | "connected-to-other-cluster" | "unknown"> {
+        if (!this.session.connectedAtlasCluster) {
+            if (this.session.serviceProvider) {
+                return "connected-to-other-cluster";
+            }
+            return "disconnected";
+        }
+
+        if (
+            this.session.connectedAtlasCluster.projectId !== projectId ||
+            this.session.connectedAtlasCluster.clusterName !== clusterName
+        ) {
+            return "connected-to-other-cluster";
+        }
+
+        if (!this.session.serviceProvider) {
+            return "connecting";
+        }
+
+        try {
+            await this.session.serviceProvider.runCommand("admin", {
+                ping: 1,
+            });
+
+            return "connected";
+        } catch (err: unknown) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            logger.debug(
+                LogId.atlasConnectFailure,
+                "atlas-connect-cluster",
+                `error querying cluster: ${error.message}`
+            );
+            return "unknown";
+        }
+    }
+
+    private async prepareClusterConnection(projectId: string, clusterName: string): Promise<string> {
+        const cluster = await inspectCluster(this.session.apiClient, projectId, clusterName);
+
+        if (!cluster.connectionString) {
+            throw new Error("Connection string not available");
+        }
+
+        const username = `mcpUser${Math.floor(Math.random() * 100000)}`;
+        const password = await generateSecurePassword();
+
+        const expiryDate = new Date(Date.now() + EXPIRY_MS);
+
+        const readOnly =
+            this.config.readOnly ||
+            (this.config.disabledTools?.includes("create") &&
+                this.config.disabledTools?.includes("update") &&
+                this.config.disabledTools?.includes("delete") &&
+                !this.config.disabledTools?.includes("read") &&
+                !this.config.disabledTools?.includes("metadata"));
+
+        const roleName = readOnly ? "readAnyDatabase" : "readWriteAnyDatabase";
+
+        await this.session.apiClient.createDatabaseUser({
+            params: {
+                path: {
+                    groupId: projectId,
+                },
+            },
+            body: {
+                databaseName: "admin",
+                groupId: projectId,
+                roles: [
+                    {
+                        roleName,
+                        databaseName: "admin",
+                    },
+                ],
+                scopes: [{ type: "CLUSTER", name: clusterName }],
+                username,
+                password,
+                awsIAMType: "NONE",
+                ldapAuthType: "NONE",
+                oidcAuthType: "NONE",
+                x509Type: "NONE",
+                deleteAfterDate: expiryDate.toISOString(),
+            },
+        });
+
+        this.session.connectedAtlasCluster = {
+            username,
+            projectId,
+            clusterName,
+            expiryDate,
+        };
+
+        const cn = new URL(cluster.connectionString);
+        cn.username = username;
+        cn.password = password;
+        cn.searchParams.set("authSource", "admin");
+        return cn.toString();
+    }
+
+    private async connectToCluster(projectId: string, clusterName: string, connectionString: string): Promise<void> {
+        let lastError: Error | undefined = undefined;
+
+        logger.debug(
+            LogId.atlasConnectAttempt,
+            "atlas-connect-cluster",
+            `attempting to connect to cluster: ${this.session.connectedAtlasCluster?.clusterName}`
+        );
+
+        // try to connect for about 5 minutes
+        for (let i = 0; i < 600; i++) {
+            if (
+                !this.session.connectedAtlasCluster ||
+                this.session.connectedAtlasCluster.projectId != projectId ||
+                this.session.connectedAtlasCluster.clusterName != clusterName
+            ) {
+                throw new Error("Cluster connection aborted");
+            }
+
+            try {
+                lastError = undefined;
+
+                await this.session.connectToMongoDB(connectionString, this.config.connectOptions);
+                break;
+            } catch (err: unknown) {
+                const error = err instanceof Error ? err : new Error(String(err));
+
+                lastError = error;
+
+                logger.debug(
+                    LogId.atlasConnectFailure,
+                    "atlas-connect-cluster",
+                    `error connecting to cluster: ${error.message}`
+                );
+
+                await sleep(500); // wait for 500ms before retrying
+            }
+        }
+
+        if (lastError) {
+            if (
+                this.session.connectedAtlasCluster?.projectId == projectId &&
+                this.session.connectedAtlasCluster?.clusterName == clusterName &&
+                this.session.connectedAtlasCluster?.username
+            ) {
+                void this.session.apiClient
+                    .deleteDatabaseUser({
+                        params: {
+                            path: {
+                                groupId: this.session.connectedAtlasCluster.projectId,
+                                username: this.session.connectedAtlasCluster.username,
+                                databaseName: "admin",
+                            },
+                        },
+                    })
+                    .catch((err: unknown) => {
+                        const error = err instanceof Error ? err : new Error(String(err));
+                        logger.debug(
+                            LogId.atlasConnectFailure,
+                            "atlas-connect-cluster",
+                            `error deleting database user: ${error.message}`
+                        );
+                    });
+            }
+            this.session.connectedAtlasCluster = undefined;
+            throw lastError;
+        }
+
+        logger.debug(
+            LogId.atlasConnectSucceeded,
+            "atlas-connect-cluster",
+            `connected to cluster: ${this.session.connectedAtlasCluster?.clusterName}`
+        );
+    }
+
+    protected async execute({ projectId, clusterName }: ToolArgs<typeof this.argsShape>): Promise<CallToolResult> {
+        await ensureCurrentIpInAccessList(this.session.apiClient, projectId);
+        for (let i = 0; i < 60; i++) {
+            const state = await this.queryConnection(projectId, clusterName);
+            switch (state) {
+                case "connected": {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Connected to cluster "${clusterName}".`,
+                            },
+                        ],
+                    };
+                }
+                case "connecting":
+                case "unknown": {
+                    break;
+                }
+                case "connected-to-other-cluster":
+                case "disconnected":
+                default: {
+                    await this.session.disconnect();
+                    const connectionString = await this.prepareClusterConnection(projectId, clusterName);
+
+                    // try to connect for about 5 minutes asynchronously
+                    void this.connectToCluster(projectId, clusterName, connectionString).catch((err: unknown) => {
+                        const error = err instanceof Error ? err : new Error(String(err));
+                        logger.error(
+                            LogId.atlasConnectFailure,
+                            "atlas-connect-cluster",
+                            `error connecting to cluster: ${error.message}`
+                        );
+                    });
+                    break;
+                }
+            }
+
+            await sleep(500);
+        }
+
+        return {
+            content: [
+                {
+                    type: "text" as const,
+                    text: `Attempting to connect to cluster "${clusterName}"...`,
+                },
+                {
+                    type: "text" as const,
+                    text: `Warning: Provisioning a user and connecting to the cluster may take more time, please check again in a few seconds.`,
+                },
+                {
+                    type: "text" as const,
+                    text: `Warning: Make sure your IP address was enabled in the allow list setting of the Atlas cluster.`,
+                },
+            ],
+        };
+    }
+}