mongodb-mcp-server 0.1.3 → 0.2.0

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.`,
+                },
+            ],
+        };
+    }
+}

package/src/tools/atlas/create/createAccessList.ts

@@ -2,13 +2,12 @@ import { z } from "zod";
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { AtlasToolBase } from "../atlasTool.js";
 import { ToolArgs, OperationType } from "../../tool.js";
-
-const DEFAULT_COMMENT = "Added by Atlas MCP";
+import { makeCurrentIpAccessListEntry, DEFAULT_ACCESS_LIST_COMMENT } from "../../../common/atlas/accessListUtils.js";
 
 export class CreateAccessListTool extends AtlasToolBase {
-    protected name = "atlas-create-access-list";
+    public name = "atlas-create-access-list";
     protected description = "Allow Ip/CIDR ranges to access your MongoDB Atlas clusters.";
-    protected operationType: OperationType = "create";
+    public operationType: OperationType = "create";
     protected argsShape = {
         projectId: z.string().describe("Atlas project ID"),
         ipAddresses: z
@@ -17,7 +16,11 @@ export class CreateAccessListTool extends AtlasToolBase {
             .optional(),
         cidrBlocks: z.array(z.string().cidr()).describe("CIDR blocks to allow access from").optional(),
         currentIpAddress: z.boolean().describe("Add the current IP address").default(false),
-        comment: z.string().describe("Comment for the access list entries").default(DEFAULT_COMMENT).optional(),
+        comment: z
+            .string()
+            .describe("Comment for the access list entries")
+            .default(DEFAULT_ACCESS_LIST_COMMENT)
+            .optional(),
     };
 
     protected async execute({
@@ -34,23 +37,22 @@ export class CreateAccessListTool extends AtlasToolBase {
         const ipInputs = (ipAddresses || []).map((ipAddress) => ({
             groupId: projectId,
             ipAddress,
-            comment: comment || DEFAULT_COMMENT,
+            comment: comment || DEFAULT_ACCESS_LIST_COMMENT,
         }));
 
         if (currentIpAddress) {
-            const currentIp = await this.session.apiClient.getIpInfo();
-            const input = {
-                groupId: projectId,
-                ipAddress: currentIp.currentIpv4Address,
-                comment: comment || DEFAULT_COMMENT,
-            };
+            const input = await makeCurrentIpAccessListEntry(
+                this.session.apiClient,
+                projectId,
+                comment || DEFAULT_ACCESS_LIST_COMMENT
+            );
             ipInputs.push(input);
         }
 
         const cidrInputs = (cidrBlocks || []).map((cidrBlock) => ({
             groupId: projectId,
             cidrBlock,
-            comment: comment || DEFAULT_COMMENT,
+            comment: comment || DEFAULT_ACCESS_LIST_COMMENT,
         }));
 
         const inputs = [...ipInputs, ...cidrInputs];

package/src/tools/atlas/create/createDBUser.ts

@@ -3,12 +3,13 @@ import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { AtlasToolBase } from "../atlasTool.js";
 import { ToolArgs, OperationType } from "../../tool.js";
 import { CloudDatabaseUser, DatabaseUserRole } from "../../../common/atlas/openapi.js";
-import { generateSecurePassword } from "../../../common/atlas/generatePassword.js";
+import { generateSecurePassword } from "../../../helpers/generatePassword.js";
+import { ensureCurrentIpInAccessList } from "../../../common/atlas/accessListUtils.js";
 
 export class CreateDBUserTool extends AtlasToolBase {
-    protected name = "atlas-create-db-user";
+    public name = "atlas-create-db-user";
     protected description = "Create an MongoDB Atlas database user";
-    protected operationType: OperationType = "create";
+    public operationType: OperationType = "create";
     protected argsShape = {
         projectId: z.string().describe("Atlas project ID"),
         username: z.string().describe("Username for the new user"),
@@ -44,6 +45,7 @@ export class CreateDBUserTool extends AtlasToolBase {
         roles,
         clusters,
     }: ToolArgs<typeof this.argsShape>): Promise<CallToolResult> {
+        await ensureCurrentIpInAccessList(this.session.apiClient, projectId);
         const shouldGeneratePassword = !password;
         if (shouldGeneratePassword) {
             password = await generateSecurePassword();

package/src/tools/atlas/create/createFreeCluster.ts

@@ -3,11 +3,12 @@ import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { AtlasToolBase } from "../atlasTool.js";
 import { ToolArgs, OperationType } from "../../tool.js";
 import { ClusterDescription20240805 } from "../../../common/atlas/openapi.js";
+import { ensureCurrentIpInAccessList } from "../../../common/atlas/accessListUtils.js";
 
 export class CreateFreeClusterTool extends AtlasToolBase {
-    protected name = "atlas-create-free-cluster";
+    public name = "atlas-create-free-cluster";
     protected description = "Create a free MongoDB Atlas cluster";
-    protected operationType: OperationType = "create";
+    public operationType: OperationType = "create";
     protected argsShape = {
         projectId: z.string().describe("Atlas project ID to create the cluster in"),
         name: z.string().describe("Name of the cluster"),
@@ -37,6 +38,7 @@ export class CreateFreeClusterTool extends AtlasToolBase {
             terminationProtectionEnabled: false,
         } as unknown as ClusterDescription20240805;
 
+        await ensureCurrentIpInAccessList(this.session.apiClient, projectId);
         await this.session.apiClient.createCluster({
             params: {
                 path: {

package/src/tools/atlas/create/createProject.ts

@@ -5,9 +5,9 @@ import { ToolArgs, OperationType } from "../../tool.js";
 import { Group } from "../../../common/atlas/openapi.js";
 
 export class CreateProjectTool extends AtlasToolBase {
-    protected name = "atlas-create-project";
+    public name = "atlas-create-project";
     protected description = "Create a MongoDB Atlas project";
-    protected operationType: OperationType = "create";
+    public operationType: OperationType = "create";
     protected argsShape = {
         projectName: z.string().optional().describe("Name for the new project"),
         organizationId: z.string().optional().describe("Organization ID for the new project"),

package/src/tools/atlas/read/inspectAccessList.ts

@@ -4,9 +4,9 @@ import { AtlasToolBase } from "../atlasTool.js";
 import { ToolArgs, OperationType } from "../../tool.js";
 
 export class InspectAccessListTool extends AtlasToolBase {
-    protected name = "atlas-inspect-access-list";
+    public name = "atlas-inspect-access-list";
     protected description = "Inspect Ip/CIDR ranges with access to your MongoDB Atlas clusters.";
-    protected operationType: OperationType = "read";
+    public operationType: OperationType = "read";
     protected argsShape = {
         projectId: z.string().describe("Atlas project ID"),
     };

package/src/tools/atlas/read/inspectCluster.ts

@@ -5,9 +5,9 @@ import { ToolArgs, OperationType } from "../../tool.js";
 import { Cluster, inspectCluster } from "../../../common/atlas/cluster.js";
 
 export class InspectClusterTool extends AtlasToolBase {
-    protected name = "atlas-inspect-cluster";
+    public name = "atlas-inspect-cluster";
     protected description = "Inspect MongoDB Atlas cluster";
-    protected operationType: OperationType = "read";
+    public operationType: OperationType = "read";
     protected argsShape = {
         projectId: z.string().describe("Atlas project ID"),
         clusterName: z.string().describe("Atlas cluster name"),

package/src/tools/atlas/read/listAlerts.ts

@@ -4,9 +4,9 @@ import { AtlasToolBase } from "../atlasTool.js";
 import { ToolArgs, OperationType } from "../../tool.js";
 
 export class ListAlertsTool extends AtlasToolBase {
-    protected name = "atlas-list-alerts";
+    public name = "atlas-list-alerts";
     protected description = "List MongoDB Atlas alerts";
-    protected operationType: OperationType = "read";
+    public operationType: OperationType = "read";
     protected argsShape = {
         projectId: z.string().describe("Atlas project ID to list alerts for"),
     };

package/src/tools/atlas/read/listClusters.ts

@@ -11,9 +11,9 @@ import {
 import { formatCluster, formatFlexCluster } from "../../../common/atlas/cluster.js";
 
 export class ListClustersTool extends AtlasToolBase {
-    protected name = "atlas-list-clusters";
+    public name = "atlas-list-clusters";
     protected description = "List MongoDB Atlas clusters";
-    protected operationType: OperationType = "read";
+    public operationType: OperationType = "read";
     protected argsShape = {
         projectId: z.string().describe("Atlas project ID to filter clusters").optional(),
     };

package/src/tools/atlas/read/listDBUsers.ts

@@ -5,9 +5,9 @@ import { ToolArgs, OperationType } from "../../tool.js";
 import { DatabaseUserRole, UserScope } from "../../../common/atlas/openapi.js";
 
 export class ListDBUsersTool extends AtlasToolBase {
-    protected name = "atlas-list-db-users";
+    public name = "atlas-list-db-users";
     protected description = "List MongoDB Atlas database users";
-    protected operationType: OperationType = "read";
+    public operationType: OperationType = "read";
     protected argsShape = {
         projectId: z.string().describe("Atlas project ID to filter DB users"),
     };

package/src/tools/atlas/read/listOrgs.ts

@@ -3,9 +3,9 @@ import { AtlasToolBase } from "../atlasTool.js";
 import { OperationType } from "../../tool.js";
 
 export class ListOrganizationsTool extends AtlasToolBase {
-    protected name = "atlas-list-orgs";
+    public name = "atlas-list-orgs";
     protected description = "List MongoDB Atlas organizations";
-    protected operationType: OperationType = "read";
+    public operationType: OperationType = "read";
     protected argsShape = {};
 
     protected async execute(): Promise<CallToolResult> {

package/src/tools/atlas/read/listProjects.ts

@@ -5,9 +5,9 @@ import { z } from "zod";
 import { ToolArgs } from "../../tool.js";
 
 export class ListProjectsTool extends AtlasToolBase {
-    protected name = "atlas-list-projects";
+    public name = "atlas-list-projects";
     protected description = "List MongoDB Atlas projects";
-    protected operationType: OperationType = "read";
+    public operationType: OperationType = "read";
     protected argsShape = {
         orgId: z.string().describe("Atlas organization ID to filter projects").optional(),
     };

package/src/tools/atlas/tools.ts

@@ -8,7 +8,7 @@ import { ListDBUsersTool } from "./read/listDBUsers.js";
 import { CreateDBUserTool } from "./create/createDBUser.js";
 import { CreateProjectTool } from "./create/createProject.js";
 import { ListOrganizationsTool } from "./read/listOrgs.js";
-import { ConnectClusterTool } from "./metadata/connectCluster.js";
+import { ConnectClusterTool } from "./connect/connectCluster.js";
 import { ListAlertsTool } from "./read/listAlerts.js";
 
 export const AtlasTools = [

package/src/tools/mongodb/{metadata → connect}/connect.ts

@@ -2,11 +2,11 @@ import { z } from "zod";
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { MongoDBToolBase } from "../mongodbTool.js";
 import { ToolArgs, OperationType } from "../../tool.js";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import assert from "assert";
-import { UserConfig } from "../../../config.js";
+import { UserConfig } from "../../../common/config.js";
 import { Telemetry } from "../../../telemetry/telemetry.js";
-import { Session } from "../../../session.js";
+import { Session } from "../../../common/session.js";
+import { Server } from "../../../server.js";
 
 const disconnectedSchema = z
     .object({
@@ -33,7 +33,7 @@ const connectedDescription =
 const disconnectedDescription = "Connect to a MongoDB instance";
 
 export class ConnectTool extends MongoDBToolBase {
-    protected name: typeof connectedName | typeof disconnectedName = disconnectedName;
+    public name: typeof connectedName | typeof disconnectedName = disconnectedName;
     protected description: typeof connectedDescription | typeof disconnectedDescription = disconnectedDescription;
 
     // Here the default is empty just to trigger registration, but we're going to override it with the correct
@@ -42,11 +42,11 @@ export class ConnectTool extends MongoDBToolBase {
         connectionString: z.string().optional(),
     };
 
-    protected operationType: OperationType = "metadata";
+    public operationType: OperationType = "connect";
 
     constructor(session: Session, config: UserConfig, telemetry: Telemetry) {
         super(session, config, telemetry);
-        session.on("close", () => {
+        session.on("disconnect", () => {
             this.updateMetadata();
         });
     }
@@ -72,10 +72,13 @@ export class ConnectTool extends MongoDBToolBase {
         };
     }
 
-    public register(server: McpServer): void {
-        super.register(server);
+    public register(server: Server): boolean {
+        if (super.register(server)) {
+            this.updateMetadata();
+            return true;
+        }
 
-        this.updateMetadata();
+        return false;
     }
 
     private updateMetadata(): void {

package/src/tools/mongodb/create/createCollection.ts

@@ -3,12 +3,12 @@ import { DbOperationArgs, MongoDBToolBase } from "../mongodbTool.js";
 import { OperationType, ToolArgs } from "../../tool.js";
 
 export class CreateCollectionTool extends MongoDBToolBase {
-    protected name = "create-collection";
+    public name = "create-collection";
     protected description =
         "Creates a new collection in a database. If the database doesn't exist, it will be created automatically.";
     protected argsShape = DbOperationArgs;
 
-    protected operationType: OperationType = "create";
+    public operationType: OperationType = "create";
 
     protected async execute({ collection, database }: ToolArgs<typeof this.argsShape>): Promise<CallToolResult> {
         const provider = await this.ensureConnected();

package/src/tools/mongodb/create/createIndex.ts

@@ -5,15 +5,15 @@ import { ToolArgs, OperationType } from "../../tool.js";
 import { IndexDirection } from "mongodb";
 
 export class CreateIndexTool extends MongoDBToolBase {
-    protected name = "create-index";
+    public name = "create-index";
     protected description = "Create an index for a collection";
     protected argsShape = {
         ...DbOperationArgs,
-        keys: z.record(z.string(), z.custom<IndexDirection>()).describe("The index definition"),
+        keys: z.object({}).catchall(z.custom<IndexDirection>()).describe("The index definition"),
         name: z.string().optional().describe("The name of the index"),
     };
 
-    protected operationType: OperationType = "create";
+    public operationType: OperationType = "create";
 
     protected async execute({
         database,

package/src/tools/mongodb/create/insertMany.ts

@@ -4,17 +4,17 @@ import { DbOperationArgs, MongoDBToolBase } from "../mongodbTool.js";
 import { ToolArgs, OperationType } from "../../tool.js";
 
 export class InsertManyTool extends MongoDBToolBase {
-    protected name = "insert-many";
+    public name = "insert-many";
     protected description = "Insert an array of documents into a MongoDB collection";
     protected argsShape = {
         ...DbOperationArgs,
         documents: z
-            .array(z.record(z.string(), z.unknown()).describe("An individual MongoDB document"))
+            .array(z.object({}).passthrough().describe("An individual MongoDB document"))
             .describe(
                 "The array of documents to insert, matching the syntax of the document argument of db.collection.insertMany()"
             ),
     };
-    protected operationType: OperationType = "create";
+    public operationType: OperationType = "create";
 
     protected async execute({
         database,

package/src/tools/mongodb/delete/deleteMany.ts

@@ -5,18 +5,19 @@ import { ToolArgs, OperationType } from "../../tool.js";
 import { checkIndexUsage } from "../../../helpers/indexCheck.js";
 
 export class DeleteManyTool extends MongoDBToolBase {
-    protected name = "delete-many";
+    public name = "delete-many";
     protected description = "Removes all documents that match the filter from a MongoDB collection";
     protected argsShape = {
         ...DbOperationArgs,
         filter: z
-            .record(z.string(), z.unknown())
+            .object({})
+            .passthrough()
             .optional()
             .describe(
                 "The query filter, specifying the deletion criteria. Matches the syntax of the filter argument of db.collection.deleteMany()"
             ),
     };
-    protected operationType: OperationType = "delete";
+    public operationType: OperationType = "delete";
 
     protected async execute({
         database,

package/src/tools/mongodb/delete/dropCollection.ts

@@ -3,13 +3,13 @@ import { DbOperationArgs, MongoDBToolBase } from "../mongodbTool.js";
 import { ToolArgs, OperationType } from "../../tool.js";
 
 export class DropCollectionTool extends MongoDBToolBase {
-    protected name = "drop-collection";
+    public name = "drop-collection";
     protected description =
         "Removes a collection or view from the database. The method also removes any indexes associated with the dropped collection.";
     protected argsShape = {
         ...DbOperationArgs,
     };
-    protected operationType: OperationType = "delete";
+    public operationType: OperationType = "delete";
 
     protected async execute({ database, collection }: ToolArgs<typeof this.argsShape>): Promise<CallToolResult> {
         const provider = await this.ensureConnected();

package/src/tools/mongodb/delete/dropDatabase.ts

@@ -3,12 +3,12 @@ import { DbOperationArgs, MongoDBToolBase } from "../mongodbTool.js";
 import { ToolArgs, OperationType } from "../../tool.js";
 
 export class DropDatabaseTool extends MongoDBToolBase {
-    protected name = "drop-database";
+    public name = "drop-database";
     protected description = "Removes the specified database, deleting the associated data files";
     protected argsShape = {
         database: DbOperationArgs.database,
     };
-    protected operationType: OperationType = "delete";
+    public operationType: OperationType = "delete";
 
     protected async execute({ database }: ToolArgs<typeof this.argsShape>): Promise<CallToolResult> {
         const provider = await this.ensureConnected();