working code

Author: blva

.github/prompts/mcp-dev.prompt.md

@@ -0,0 +1,7 @@
+You will use all your knowledge to implement the Atlas MCP server.
+To understand how to develop the MCP server, you also need some context about Atlas.
+
+1. https://github.com/mongodb/atlas-sdk-go is an auto-generated Atlas Golang SDK
+2. https://github.com/mongodb/openapi is a great open source of truth to the Atlas Admin API, https://github.com/mongodb/openapi/blob/main/openapi/v2/openapi-2025-03-12.yaml contains the latest available API documentation.
+3. https://github.com/mongodb/mongodb-atlas-cli is a great open source of truth for how to autogenerate code from the OpenAPI spec.
+4. https://github.com/mongodb/mongodb-atlas-cli/tree/master/internal/cli/authis a great open source of truth for how to implement authentication.

.gitignore

@@ -1,2 +1,5 @@
 node_modules
-.vscode/mcp.json
+.vscode/mcp.json
+
+# Environment variables
+.env

README.md

@@ -19,8 +19,15 @@ npm install
 npm run build
 ```
 
-## Troubleshooting
+## Troubleshooting (Via VSCode Insiders)
 
+### Restart server
+- Run `npm run build` to re-build the server if you made changes to the code
+- Press `Cmd + Shift + P` and type List MCP Servers
+- Select the MCP server you want to restart
+- Select the option to restart the server
+
+### Logs
 To see MCP logs, check https://code.visualstudio.com/docs/copilot/chat/mcp-servers.
 
 - Press `Cmd + Shift + P` and type List MCP Servers

dist/index.js

@@ -1,39 +1,151 @@
 #!/usr/bin/env node
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
-const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import express from "express"; // Fixing type imports
+import dotenv from "dotenv";
+dotenv.config();
+// Replace require() with dynamic import for node-fetch
+const fetchDynamic = async () => (await import("node-fetch")).default;
 function wait(milliseconds) {
     return new Promise(resolve => setTimeout(resolve, milliseconds));
 }
-const server = new mcp_js_1.McpServer({
+const server = new McpServer({
     name: "MongoDB Atlas",
     version: "1.0.0"
 });
+// Move clientId to a state variable
 var state = {
     auth: false,
+    token: "", // Added token property
+    deviceCode: "",
+    verificationUri: "",
+    userCode: "",
+    clientId: process.env.CLIENT_ID || "0oabtxactgS3gHIR0297", // Moved clientId to state
 };
-server.tool("auth", "Authenticate to atlas", (_a) => __awaiter(void 0, [_a], void 0, function* ({}) {
-    yield wait(1000);
-    setTimeout(() => {
-        console.error("Authenticated");
-        state.auth = true;
-    }, 10000);
+const app = express();
+let authCode = "";
+app.get("/callback", (req, res) => {
+    authCode = req.query.code;
+    res.send("Authentication successful! You can close this tab.");
+});
+// Update the device code request to align with the Atlas Go SDK
+server.tool("auth", "Authenticate to Atlas", async ({}) => {
+    console.log("Starting authentication process...");
+    const authUrl = "https://cloud.mongodb.com/api/private/unauth/account/device/authorize"; // Updated endpoint
+    console.log("Client ID:", state.clientId);
+    // Step 1: Request a device code
+    const deviceCodeResponse = await (await fetchDynamic())(authUrl, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/x-www-form-urlencoded",
+        },
+        body: new URLSearchParams({
+            client_id: state.clientId, // Use state.clientId
+            scope: "openid",
+        }).toString(),
+    });
+    const responseText = await deviceCodeResponse.text(); // Capture the full response body
+    console.log("Device Code Response Body:", responseText);
+    if (!deviceCodeResponse.ok) {
+        console.error("Failed to initiate authentication:", deviceCodeResponse.statusText);
+        return {
+            content: [{ type: "text", text: `Failed to initiate authentication: ${deviceCodeResponse.statusText}` }],
+        };
+    }
+    const deviceCodeData = JSON.parse(responseText); // Parse the response body
+    console.log(`Please authenticate by visiting the following URL: ${deviceCodeData.verification_uri}`);
+    console.log(`Enter the code: ${deviceCodeData.user_code}`);
+    // Store the device code data for further use
+    state.deviceCode = deviceCodeData.device_code;
+    state.verificationUri = deviceCodeData.verification_uri;
+    state.userCode = deviceCodeData.user_code;
     return {
-        content: [{ type: "text", text: "Navigate to http://cloud.mongodb.com and input code A56T88." }],
+        content: [
+            { type: "text", text: `Please authenticate by visiting ${deviceCodeData.verification_uri} and entering the code ${deviceCodeData.user_code}` },
+        ],
     };
-}));
-server.tool("list-clusters", "Lists clusters", (_a) => __awaiter(void 0, [_a], void 0, function* ({}) {
-    yield wait(1000);
+});
+// Add PollToken functionality to the auth tool
+server.tool("poll-token", "Poll for Access Token", async ({}) => {
+    console.log("Starting token polling process...");
+    if (!state.deviceCode) {
+        console.error("Device code not found. Please initiate authentication first.");
+        return {
+            content: [{ type: "text", text: "Device code not found. Please initiate authentication first." }],
+        };
+    }
+    const tokenEndpoint = "https://cloud.mongodb.com/api/private/unauth/account/device/token";
+    const interval = 5 * 1000; // Default polling interval in milliseconds
+    const expiresAt = Date.now() + 15 * 60 * 1000; // Assume 15 minutes expiration for the device code
+    while (Date.now() < expiresAt) {
+        await wait(interval);
+        try {
+            const tokenResponse = await (await fetchDynamic())(tokenEndpoint, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/x-www-form-urlencoded",
+                },
+                body: new URLSearchParams({
+                    client_id: state.clientId, // Use state.clientId
+                    device_code: state.deviceCode,
+                    grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+                }).toString(),
+            });
+            const responseText = await tokenResponse.text();
+            console.log("Token Response Body:", responseText);
+            if (tokenResponse.ok) {
+                const tokenData = JSON.parse(responseText);
+                console.log("Authentication successful. Token received:", tokenData.access_token);
+                // Store the token
+                state.auth = true;
+                state.token = tokenData.access_token;
+                return {
+                    content: [{ type: "text", text: "Authentication successful! You are now logged in." }],
+                };
+            }
+            else {
+                console.error("Token Response Error:", responseText);
+                const errorResponse = JSON.parse(responseText);
+                if (errorResponse.error === "authorization_pending") {
+                    console.log("Authorization pending. Retrying...");
+                    continue;
+                }
+                else if (errorResponse.error === "expired_token") {
+                    console.error("Device code expired. Please restart the authentication process.");
+                    return {
+                        content: [{ type: "text", text: "Device code expired. Please restart the authentication process." }],
+                    };
+                }
+                else {
+                    console.error("Failed to authenticate:", errorResponse.error_description || "Unknown error");
+                    return {
+                        content: [{ type: "text", text: `Failed to authenticate: ${errorResponse.error_description || "Unknown error"}` }],
+                    };
+                }
+            }
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                console.error("Unexpected error during token polling:", error);
+                return {
+                    content: [{ type: "text", text: `Unexpected error during token polling: ${error.message}` }],
+                };
+            }
+            else {
+                console.error("Unexpected non-Error object during token polling:", error);
+                return {
+                    content: [{ type: "text", text: "Unexpected error during token polling." }],
+                };
+            }
+        }
+    }
+    console.error("Authentication timed out. Please restart the process.");
+    return {
+        content: [{ type: "text", text: "Authentication timed out. Please restart the process." }],
+    };
+});
+server.tool("list-clusters", "Lists clusters", async ({}) => {
+    await wait(1000);
     if (!state.auth) {
         return {
             content: [{ type: "text", text: "Not authenticated" }],
@@ -50,12 +162,10 @@ server.tool("list-clusters", "Lists clusters", (_a) => __awaiter(void 0, [_a], v
     return {
         content: [{ type: "text", text }],
     };
-}));
-function runServer() {
-    return __awaiter(this, void 0, void 0, function* () {
-        const transport = new stdio_js_1.StdioServerTransport();
-        yield server.connect(transport);
-    });
+});
+async function runServer() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
 }
 runServer().catch((error) => {
     console.error("Fatal error running server:", error);