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

# Conflicts:
#	api-extractor/reports/mongodb-mcp-server.public.api.md
#	api-extractor/reports/tools.public.api.md
#	api-extractor/reports/web.public.api.md
#	packages/atlas-telemetry/src/types.ts
#	src/tools/atlas/tools.ts
#	src/web.ts

Author: gagik

api-extractor/reports/web.public.api.md

@@ -83,8 +83,14 @@ export interface AtlasClusterConnectionInfo {
     // (undocumented)
     expiryDate: Date;
     // (undocumented)
+    instanceType: "FREE" | "FLEX" | "DEDICATED";
+    // (undocumented)
     projectId: string;
     // (undocumented)
+    provider?: string;
+    // (undocumented)
+    region?: string;
+    // (undocumented)
     username: string;
 }
 

knip.ts

@@ -25,6 +25,23 @@ const config: KnipConfig = {
         "packages/types": {
             ignoreDependencies: ["@modelcontextprotocol/sdk", "mongodb-redact"],
         },
+        "packages/tools-mongodb": {
+            ignoreDependencies: [
+                "@mongodb-js/device-id",
+                "@mongodb-js/mcp-core",
+                "@mongodb-js/mcp-logging",
+                "@mongodb-js/mcp-types",
+                "@mongosh/arg-parser",
+                "@mongosh/service-provider-node-driver",
+                "bson",
+                "mongodb",
+                "mongodb-build-info",
+                "mongodb-connection-string-url",
+                "mongodb-schema",
+                "node-machine-id",
+                "zod",
+            ],
+        },
         "tests/browser": {
             entry: ["tests/**/*.ts", "polyfills/**/*.ts", "utils/**/*.ts", "vitest.config.ts", "setup.ts"],
         },

packages/atlas-api-client/src/apiClient.ts

@@ -10,6 +10,7 @@ import type { Credentials, AuthProvider } from "./auth/authProvider.js";
 import { AuthProviderFactory } from "./auth/authProvider.js";
 
 const ATLAS_API_VERSION = "2025-03-12";
+const LEGACY_ATLAS_API_VERSION = "2023-01-01";
 const DEFAULT_SEND_TIMEOUT_MS = 5_000;
 
 /**
@@ -860,4 +861,78 @@ export class ApiClient implements IApiClient {
     }
     /* eslint-enable @typescript-eslint/no-unsafe-assignment */
     // DO NOT EDIT. This is auto-generated code.
+
+    async upgradeSharedTierCluster(options: {
+        groupId: string;
+        body: {
+            name: string;
+            providerSettings: {
+                providerName?: string;
+                instanceSizeName: "FLEX" | "M10";
+                backingProviderName?: string;
+                regionName?: string;
+            };
+        };
+    }): Promise<{ id?: string }> {
+        const authHeaders = (await this.authProvider?.getAuthHeaders()) ?? {};
+        const url = new URL(`api/atlas/v2/groups/${options.groupId}/clusters/tenantUpgrade`, this.options.baseUrl);
+        const response = await this.customFetch(url.toString(), {
+            method: "POST",
+            signal: AbortSignal.timeout(DEFAULT_SEND_TIMEOUT_MS),
+            headers: {
+                ...authHeaders,
+                "Content-Type": `application/vnd.atlas.${LEGACY_ATLAS_API_VERSION}+json`,
+                Accept: `application/vnd.atlas.${LEGACY_ATLAS_API_VERSION}+json`,
+                "User-Agent": this.options.userAgent,
+            },
+            body: JSON.stringify(options.body),
+        });
+        if (!response.ok) {
+            throw await ApiClientError.fromResponse(response);
+        }
+        return (await response.json()) as { id?: string };
+    }
+
+    async upgradeFlexToDedicated(options: {
+        groupId: string;
+        body: {
+            name: string;
+            clusterType: "REPLICASET";
+            replicationSpecs: Array<{
+                regionConfigs: Array<{
+                    providerName?: string;
+                    regionName?: string;
+                    priority: number;
+                    electableSpecs: { instanceSize: string; nodeCount: number };
+                }>;
+            }>;
+            autoScaling: {
+                compute: {
+                    enabled: boolean;
+                    scaleDownEnabled: boolean;
+                    minInstanceSize: string;
+                    maxInstanceSize: string;
+                };
+                diskGBEnabled: boolean;
+            };
+        };
+    }): Promise<{ id?: string }> {
+        const authHeaders = (await this.authProvider?.getAuthHeaders()) ?? {};
+        const url = new URL(`api/atlas/v2/groups/${options.groupId}/flexClusters:tenantUpgrade`, this.options.baseUrl);
+        const response = await this.customFetch(url.toString(), {
+            method: "POST",
+            signal: AbortSignal.timeout(DEFAULT_SEND_TIMEOUT_MS),
+            headers: {
+                ...authHeaders,
+                "Content-Type": `application/vnd.atlas.${ATLAS_API_VERSION}+json`,
+                Accept: `application/vnd.atlas.${ATLAS_API_VERSION}+json`,
+                "User-Agent": this.options.userAgent,
+            },
+            body: JSON.stringify(options.body),
+        });
+        if (!response.ok) {
+            throw await ApiClientError.fromResponse(response);
+        }
+        return (await response.json()) as { id?: string };
+    }
 }

packages/tools-atlas/src/helpers/cluster.ts

@@ -21,6 +21,8 @@ export interface Cluster {
     name?: string;
     instanceType: "FREE" | "DEDICATED" | "FLEX";
     instanceSize?: string;
+    provider?: string;
+    region?: string;
     state?: "IDLE" | "CREATING" | "UPDATING" | "DELETING" | "REPAIRING";
     mongoDBVersion?: string;
     connectionStrings?: ClusterConnectionStrings;
@@ -32,6 +34,8 @@ export function formatFlexCluster(cluster: FlexClusterDescription20241113): Clus
         name: cluster.name,
         instanceType: "FLEX",
         instanceSize: undefined,
+        provider: cluster.providerSettings?.backingProviderName,
+        region: cluster.providerSettings?.regionName,
         state: cluster.stateName,
         mongoDBVersion: cluster.mongoDBVersion,
         connectionStrings: cluster.connectionStrings,
@@ -70,10 +74,19 @@ export function formatCluster(cluster: ClusterDescription20240805): Cluster {
     const instanceSize = regionConfigs[0]?.instanceSize ?? "UNKNOWN";
     const clusterInstanceType = instanceSize === "M0" ? "FREE" : "DEDICATED";
 
+    const primaryRegionConfig = cluster.replicationSpecs?.[0]?.regionConfigs?.[0] as
+        | { backingProviderName?: string; providerName?: string; regionName?: string }
+        | undefined;
+    const provider =
+        clusterInstanceType === "FREE" ? primaryRegionConfig?.backingProviderName : primaryRegionConfig?.providerName;
+    const region = primaryRegionConfig?.regionName;
+
     return {
         name: cluster.name,
         instanceType: clusterInstanceType,
         instanceSize: clusterInstanceType === "DEDICATED" ? instanceSize : undefined,
+        provider,
+        region,
         state: cluster.stateName,
         mongoDBVersion: cluster.mongoDBVersion,
         connectionStrings: cluster.connectionStrings,

packages/tools-atlas/src/tools/connect/connectCluster.ts

@@ -123,6 +123,9 @@ export class ConnectClusterTool extends AtlasToolBase {
             username,
             projectId,
             clusterName,
+            instanceType: cluster.instanceType,
+            provider: cluster.provider,
+            region: cluster.region,
             expiryDate,
         };
 

packages/tools-mongodb/package.json

@@ -12,7 +12,9 @@
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "files": ["dist"],
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "compile": "tsc --build tsconfig.json"
   },

src/common/connectionInfo.ts

@@ -29,6 +29,9 @@ export interface AtlasClusterConnectionInfo {
     username: string;
     projectId: string;
     clusterName: string;
+    instanceType: "FREE" | "FLEX" | "DEDICATED";
+    provider?: string;
+    region?: string;
     expiryDate: Date;
 }
 

tests/integration/common/connectionManager.test.ts

@@ -142,6 +142,7 @@ describeWithMongoDB("Connection Manager", (integration) => {
                 username: "",
                 projectId: "",
                 clusterName: "My Atlas Cluster",
+                instanceType: "FREE" as const,
                 expiryDate: new Date(),
             };
 

tests/integration/tools/atlas/clusters.test.ts

@@ -265,5 +265,75 @@ describeWithAtlas("clusters", (integration) => {
                 });
             });
         });
+        describe("atlas-upgrade-cluster", () => {
+            it("should have correct metadata", async () => {
+                const { tools } = await integration.mcpClient().listTools();
+                const upgradeCluster = tools.find((tool) => tool.name === "atlas-upgrade-cluster");
+
+                expectDefined(upgradeCluster);
+                expect(upgradeCluster.inputSchema.type).toBe("object");
+                expectDefined(upgradeCluster.inputSchema.properties);
+                expect(upgradeCluster.inputSchema.properties).toHaveProperty("projectId");
+                expect(upgradeCluster.inputSchema.properties).toHaveProperty("clusterName");
+                expect(upgradeCluster.inputSchema.properties).toHaveProperty("targetTier");
+                expect(upgradeCluster.inputSchema.properties).toHaveProperty("provider");
+                expect(upgradeCluster.inputSchema.properties).toHaveProperty("region");
+            });
+
+            withCluster(integration, ({ getProjectId: getUpgradeProjectId, getClusterName: getUpgradeClusterName }) => {
+                // This withCluster creates a dedicated FREE cluster for the upgrade test.
+                // The test makes a real upgrade API call; withCluster's cleanup handles teardown regardless of tier.
+                describe("when not connected to the cluster being upgraded", () => {
+                    it("upgrades FREE cluster to FLEX with explicit projectId and clusterName", async () => {
+                        const response = await integration.mcpClient().callTool({
+                            name: "atlas-upgrade-cluster",
+                            arguments: {
+                                projectId: getUpgradeProjectId(),
+                                clusterName: getUpgradeClusterName(),
+                            },
+                        });
+                        const content = getResponseContent(response.content);
+                        expect(content).toContain(getUpgradeClusterName());
+                        expect(content).toContain("being upgraded");
+                    });
+                });
+            });
+
+            // Simulates being "connected" to the outer cluster (created by atlas-create-free-cluster above).
+            // The session state is patched so the tool picks up projectId/clusterName without explicit args,
+            // then makes a real upgrade API call against that outer cluster.
+            describe("when connected to the cluster being upgraded", () => {
+                beforeAll(() => {
+                    const session: Session = integration.mcpServer().session;
+                    (session.connectionManager as unknown as { state: unknown }).state = {
+                        tag: "disconnected",
+                        connectedAtlasCluster: {
+                            username: "testuser",
+                            projectId: getProjectId(),
+                            clusterName,
+                            instanceType: "FREE" as const,
+                            provider: "AWS",
+                            region: "US_EAST_1",
+                            expiryDate: new Date(Date.now() + 3_600_000),
+                        },
+                    };
+                });
+
+                afterAll(() => {
+                    const session: Session = integration.mcpServer().session;
+                    (session.connectionManager as unknown as { state: unknown }).state = { tag: "disconnected" };
+                });
+
+                it("upgrades FREE cluster to FLEX using session state without explicit params", async () => {
+                    const response = await integration.mcpClient().callTool({
+                        name: "atlas-upgrade-cluster",
+                        arguments: {},
+                    });
+                    const content = getResponseContent(response.content);
+                    expect(content).toContain(clusterName);
+                    expect(content).toContain("being upgraded");
+                });
+            });
+        });
     });
 });

tests/unit/common/apiClient.test.ts

@@ -267,4 +267,107 @@ describe("ApiClient", () => {
             await expect(apiClient.sendEvents({ events: mockEvents })).rejects.toThrow();
         });
     });
+
+    describe("upgradeSharedTierCluster", () => {
+        const upgradeOptions = {
+            groupId: "test-group-id",
+            body: {
+                name: "MyCluster",
+                providerSettings: {
+                    providerName: "FLEX",
+                    instanceSizeName: "FLEX" as const,
+                    backingProviderName: "AWS",
+                    regionName: "US_EAST_1",
+                },
+            },
+        };
+
+        it("should POST to the tenant upgrade endpoint with legacy API version headers", async () => {
+            const mockCustomFetch = vi
+                .spyOn(apiClient as unknown as { customFetch: typeof fetch }, "customFetch")
+                .mockResolvedValue(new Response(JSON.stringify({ id: "upgraded-cluster-id" }), { status: 200 }));
+
+            const result = await apiClient.upgradeSharedTierCluster(upgradeOptions);
+
+            expect(mockCustomFetch).toHaveBeenCalledWith(
+                "https://api.test.com/api/atlas/v2/groups/test-group-id/clusters/tenantUpgrade",
+                expect.objectContaining({
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/vnd.atlas.2023-01-01+json",
+                        Accept: "application/vnd.atlas.2023-01-01+json",
+                        Authorization: "Bearer mockToken",
+                        "User-Agent": "test-user-agent",
+                    },
+                    body: JSON.stringify(upgradeOptions.body),
+                })
+            );
+            expect(result).toEqual({ id: "upgraded-cluster-id" });
+        });
+
+        it("should throw when the response is not ok", async () => {
+            vi.spyOn(apiClient as unknown as { customFetch: typeof fetch }, "customFetch").mockResolvedValue(
+                new Response(JSON.stringify({ error: "Bad Request" }), { status: 400 })
+            );
+
+            await expect(apiClient.upgradeSharedTierCluster(upgradeOptions)).rejects.toThrow();
+        });
+    });
+
+    describe("upgradeFlexToDedicated", () => {
+        const upgradeOptions = {
+            groupId: "test-group-id",
+            body: {
+                name: "MyCluster",
+                clusterType: "REPLICASET" as const,
+                replicationSpecs: [
+                    {
+                        regionConfigs: [
+                            {
+                                providerName: "AWS",
+                                regionName: "US_EAST_1",
+                                priority: 7,
+                                electableSpecs: { instanceSize: "M10", nodeCount: 3 },
+                            },
+                        ],
+                    },
+                ],
+                autoScaling: {
+                    compute: { enabled: true, scaleDownEnabled: true, minInstanceSize: "M10", maxInstanceSize: "M30" },
+                    diskGBEnabled: true,
+                },
+            },
+        };
+
+        it("should POST to the flex tenant upgrade endpoint with current API version headers", async () => {
+            const mockCustomFetch = vi
+                .spyOn(apiClient as unknown as { customFetch: typeof fetch }, "customFetch")
+                .mockResolvedValue(new Response(JSON.stringify({ id: "upgraded-cluster-id" }), { status: 200 }));
+
+            const result = await apiClient.upgradeFlexToDedicated(upgradeOptions);
+
+            expect(mockCustomFetch).toHaveBeenCalledWith(
+                "https://api.test.com/api/atlas/v2/groups/test-group-id/flexClusters:tenantUpgrade",
+                expect.objectContaining({
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/vnd.atlas.2025-03-12+json",
+                        Accept: "application/vnd.atlas.2025-03-12+json",
+                        Authorization: "Bearer mockToken",
+                        "User-Agent": "test-user-agent",
+                    },
+                    body: JSON.stringify(upgradeOptions.body),
+                })
+            );
+            expect(result).toEqual({ id: "upgraded-cluster-id" });
+        });
+
+        it("should throw when the response is not ok", async () => {
+            vi.spyOn(apiClient as unknown as { customFetch: typeof fetch }, "customFetch").mockResolvedValue(
+                new Response(JSON.stringify({ error: "Bad Request" }), { status: 400 })
+            );
+
+            await expect(apiClient.upgradeFlexToDedicated(upgradeOptions)).rejects.toThrow();
+        });
+    });
 });