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

Author: fmenezes

package-lock.json

@@ -27,21 +27,32 @@
     "check": "npm run check:lint && npm run check:format",
     "check:lint": "eslint .",
     "check:format": "prettier -c .",
-    "reformat": "prettier --write ."
+    "reformat": "prettier --write .",
+    "generate:download": "curl -Lo ./scripts/spec.json https://github.com/mongodb/openapi/raw/refs/heads/main/openapi/v2/openapi-2025-03-12.json",
+    "generate:filter": "tsx ./scripts/filter.ts > ./scripts/filteredSpec.json < ./scripts/spec.json",
+    "generate:bundle": "redocly bundle --ext json --remove-unused-components ./scripts/filteredSpec.json --output ./scripts/bundledSpec.json",
+    "generate:openapi": "openapi-typescript ./scripts/bundledSpec.json --root-types-no-schema-prefix --root-types --output ./src/common/atlas/openapi.d.ts",
+    "generate:clear": "rm -rf ./scripts/bundledSpec.json ./scripts/filteredSpec.json ./scripts/spec.json",
+    "generate": "npm run generate:download && npm run generate:filter && npm run generate:bundle && npm run generate:openapi && npm run generate:clear"
   },
   "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",

package.json

@@ -0,0 +1,57 @@
+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/filter.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/common/atlas/auth.ts

@@ -1,4 +1,7 @@
-import config from "./config.js";
+import { log } from "console";
+import config from "../../config.js";
+
+import { Group, PaginatedOrgGroupView, PaginatedAtlasGroupView, ClusterDescription20240805, PaginatedClusterDescription20240805 } from "./openapi.js"
 
 export interface OAuthToken {
     access_token: string;
@@ -10,27 +13,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 +21,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 +97,13 @@ export class ApiClient {
                 ...options?.headers,
             },
         };
+
+        console.error(`Calling Atlas API: ${url.toString()}`);
+        console.error(`with: ${JSON.stringify(opt)}`);
         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 +262,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),
+        });
     }
 }