feat: add atlas-create-free-cluster atlas-inspect-cluster tools

package.json

@@ -24,24 +24,30 @@
     "build": "npm run build:clean && npm run build:compile && npm run build:addshebang && npm run build:chmod",
     "inspect": "npm run build && mcp-inspector -- dist/index.js",
     "prettier": "prettier",
-    "check": "npm run check:lint && npm run check:format",
+    "check": "npm run build && npm run check:lint && npm run check:format",
     "check:lint": "eslint .",
     "check:format": "prettier -c .",
-    "reformat": "prettier --write ."
+    "reformat": "prettier --write .",
+    "generate": "./scripts/generate.sh"
   },
   "license": "Apache-2.0",
   "devDependencies": {
     "@eslint/js": "^9.24.0",
     "@modelcontextprotocol/inspector": "^0.8.2",
     "@modelcontextprotocol/sdk": "^1.8.0",
+    "@redocly/cli": "^1.34.2",
     "@types/node": "^22.14.0",
     "@types/simple-oauth2": "^5.0.7",
     "eslint": "^9.24.0",
     "eslint-config-prettier": "^10.1.1",
     "globals": "^16.0.0",
+    "openapi-types": "^12.1.3",
+    "openapi-typescript": "^7.6.1",
     "prettier": "^3.5.3",
+    "tsx": "^4.19.3",
     "typescript": "^5.8.2",
-    "typescript-eslint": "^8.29.1"
+    "typescript-eslint": "^8.29.1",
+    "yaml": "^2.7.1"
   },
   "dependencies": {
     "@mongodb-js/devtools-connect": "^3.7.2",

scripts/filter.ts

@@ -0,0 +1,56 @@
+import { OpenAPIV3_1 } from "openapi-types";
+
+async function readStdin() {
+    return new Promise<string>((resolve, reject) => {
+        let data = "";
+        process.stdin.setEncoding("utf8");
+        process.stdin.on("error", (err) => {
+            reject(err);
+        });
+        process.stdin.on("data", (chunk) => {
+            data += chunk;
+        });
+        process.stdin.on("end", () => {
+            resolve(data);
+        });
+    });
+}
+
+function filterOpenapi(openapi: OpenAPIV3_1.Document): OpenAPIV3_1.Document {
+    const allowedOperations = [
+        "listProjects",
+        "getProject",
+        "createProject",
+        "listClusters",
+        "createCluster",
+        "listClustersForAllProjects",
+    ];
+
+    const filteredPaths = {};
+
+    for (const path in openapi.paths) {
+        const filteredMethods = {} as OpenAPIV3_1.PathItemObject;
+        for (const method in openapi.paths[path]) {
+            if (allowedOperations.includes(openapi.paths[path][method].operationId)) {
+                filteredMethods[method] = openapi.paths[path][method];
+            }
+        }
+        if (Object.keys(filteredMethods).length > 0) {
+            filteredPaths[path] = filteredMethods;
+        }
+    }
+
+    return { ...openapi, paths: filteredPaths };
+}
+
+async function main() {
+    const openapiText = await readStdin();
+    const openapi = JSON.parse(openapiText) as OpenAPIV3_1.Document;
+    const filteredOpenapi = filterOpenapi(openapi);
+    console.log(JSON.stringify(filteredOpenapi));
+}
+
+main().catch((error) => {
+    console.error("Error:", error);
+    process.exit(1);
+});

scripts/generate.sh

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+
+set -Eeou pipefail
+
+curl -Lo ./scripts/spec.json https://github.com/mongodb/openapi/raw/refs/heads/main/openapi/v2/openapi-2025-03-12.json
+tsx ./scripts/filter.ts > ./scripts/filteredSpec.json < ./scripts/spec.json
+redocly bundle --ext json --remove-unused-components ./scripts/filteredSpec.json --output ./scripts/bundledSpec.json
+openapi-typescript ./scripts/bundledSpec.json --root-types-no-schema-prefix --root-types --output ./src/common/atlas/openapi.d.ts
+prettier --write ./src/common/atlas/openapi.d.ts
+rm -rf ./scripts/bundledSpec.json ./scripts/filteredSpec.json ./scripts/spec.json

src/common/atlas/auth.ts

@@ -0,0 +1,32 @@
+import { ApiClient } from "./client";
+import { State } from "../../state";
+
+export async function ensureAuthenticated(state: State, apiClient: ApiClient): Promise<void> {
+    if (!(await isAuthenticated(state, apiClient))) {
+        throw new Error("Not authenticated");
+    }
+}
+
+export async function isAuthenticated(state: State, apiClient: ApiClient): Promise<boolean> {
+    switch (state.auth.status) {
+        case "not_auth":
+            return false;
+        case "requested":
+            try {
+                if (!state.auth.code) {
+                    return false;
+                }
+                await apiClient.retrieveToken(state.auth.code.device_code);
+                return !!state.auth.token;
+            } catch {
+                return false;
+            }
+        case "issued":
+            if (!state.auth.token) {
+                return false;
+            }
+            return await apiClient.validateToken();
+        default:
+            throw new Error("Unknown authentication status");
+    }
+}

src/client.ts → src/common/atlas/client.ts

@@ -1,4 +1,12 @@
-import config from "./config.js";
+import config from "../../config.js";
+
+import {
+    Group,
+    PaginatedOrgGroupView,
+    PaginatedAtlasGroupView,
+    ClusterDescription20240805,
+    PaginatedClusterDescription20240805,
+} from "./openapi.js";
 
 export interface OAuthToken {
     access_token: string;
@@ -10,27 +18,6 @@ export interface OAuthToken {
     expiry: Date;
 }
 
-export interface AtlasProject {
-    id: string;
-    name: string;
-    created?: {
-        $date: string;
-    };
-}
-
-export interface AtlasCluster {
-    id?: string;
-    name: string;
-    stateName: string;
-    mongoDBVersion?: string;
-    providerSettings?: {
-        regionName?: string;
-    };
-    connectionStrings?: {
-        standard?: string;
-    };
-}
-
 export interface OauthDeviceCode {
     user_code: string;
     verification_uri: string;
@@ -39,11 +26,6 @@ export interface OauthDeviceCode {
     interval: string;
 }
 
-export interface AtlasResponse<T> {
-    results: T[];
-    totalCount?: number;
-}
-
 export type saveTokenFunction = (token: OAuthToken) => void | Promise<void>;
 
 export class ApiClientError extends Error {
@@ -120,10 +102,11 @@ export class ApiClient {
                 ...options?.headers,
             },
         };
+
         const response = await fetch(url, opt);
 
         if (!response.ok) {
-            throw new ApiClientError(`Error calling Atlas API: ${response.statusText}`, response);
+            throw new ApiClientError(`Error calling Atlas API: ${await response.text()}`, response);
         }
 
         return (await response.json()) as T;
@@ -282,31 +265,33 @@ export class ApiClient {
         }
     }
 
-    /**
-     * Get all projects for the authenticated user
-     */
-    async listProjects(): Promise<AtlasResponse<AtlasProject>> {
-        return await this.do<AtlasResponse<AtlasProject>>("/groups");
+    async listProjects(): Promise<PaginatedAtlasGroupView> {
+        return await this.do<PaginatedAtlasGroupView>("/groups");
     }
 
-    /**
-     * Get a specific project by ID
-     */
-    async getProject(projectId: string): Promise<AtlasProject> {
-        return await this.do<AtlasProject>(`/groups/${projectId}`);
+    async getProject(groupId: string): Promise<Group> {
+        return await this.do<Group>(`/groups/${groupId}`);
     }
 
-    /**
-     * Get clusters for a specific project
-     */
-    async listProjectClusters(projectId: string): Promise<AtlasResponse<AtlasCluster>> {
-        return await this.do<AtlasResponse<AtlasCluster>>(`/groups/${projectId}/clusters`);
+    async listClusters(groupId: string): Promise<PaginatedClusterDescription20240805> {
+        return await this.do<PaginatedClusterDescription20240805>(`/groups/${groupId}/clusters`);
     }
 
-    /**
-     * Get clusters for a specific project
-     */
-    async listAllClusters(): Promise<AtlasResponse<AtlasCluster>> {
-        return await this.do<AtlasResponse<AtlasCluster>>(`/clusters`);
+    async listClustersForAllProjects(): Promise<PaginatedOrgGroupView> {
+        return await this.do<PaginatedOrgGroupView>(`/clusters`);
+    }
+
+    async getCluster(groupId: string, clusterName: string): Promise<ClusterDescription20240805> {
+        return await this.do<ClusterDescription20240805>(`/groups/${groupId}/clusters/${clusterName}`);
+    }
+
+    async createCluster(groupId: string, cluster: ClusterDescription20240805): Promise<ClusterDescription20240805> {
+        if (!cluster.groupId) {
+            throw new Error("Cluster groupId is required");
+        }
+        return await this.do<ClusterDescription20240805>(`/groups/${groupId}/clusters`, {
+            method: "POST",
+            body: JSON.stringify(cluster),
+        });
     }
 }