@dynatrace-oss/dynatrace-mcp-server 0.9.0 → 0.9.2

package/dist/authentication/dynatrace-clients.js

@@ -80,7 +80,8 @@ const createOAuthClientCredentialsHttpClient = async (environmentUrl, scopes, cl
 };
 /** Create an OAuth Client using authorization code flow (interactive authentication)
  * This starts a local HTTP server to handle the OAuth redirect and requires user interaction.
- * Implements token caching (via .dt-mcp/token.json) to avoid repeated OAuth flows.
+ * Implements an in-memory token cache (not persisted to disk). After every server restart a new
+ * authentication flow (or token refresh) may be required.
  * Note: Always requests a complete set of scopes for maximum token reusability. Else the user will end up having to approve multiple requests.
  */
 const createOAuthAuthCodeFlowHttpClient = async (environmentUrl, scopes, clientId) => {

package/dist/authentication/token-cache.js

@@ -1,149 +1,54 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.globalTokenCache = exports.FileTokenCache = void 0;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
+exports.globalTokenCache = exports.InMemoryTokenCache = void 0;
 /**
- * File-based token cache implementation that persists tokens to disk
- * Stores tokens in .dt-mcp/token.json for persistence across dynatrace-mcp-server restarts
+ * In-memory token cache implementation (no persistence across process restarts).
+ * The previous implementation stored tokens on disk in `.dt-mcp/token.json` – this has been
+ * intentionally removed to avoid writing credentials to the local filesystem. A new login /
+ * OAuth authorization code flow (or token retrieval) will be required after every server restart.
  */
-class FileTokenCache {
-    tokenFilePath;
+class InMemoryTokenCache {
     token = null;
-    constructor() {
-        // Create .dt-mcp directory in the current working directory
-        const tokenDir = path.join(process.cwd(), '.dt-mcp');
-        this.tokenFilePath = path.join(tokenDir, 'token.json');
-        // Ensure the directory exists
-        if (!fs.existsSync(tokenDir)) {
-            fs.mkdirSync(tokenDir, { recursive: true });
-        }
-        this.loadToken();
-    }
-    /**
-     * Loads the token from the file system
-     */
-    loadToken() {
-        try {
-            if (fs.existsSync(this.tokenFilePath)) {
-                const tokenData = fs.readFileSync(this.tokenFilePath, 'utf8');
-                this.token = JSON.parse(tokenData);
-                console.error(`🔍 Loaded token from file: ${this.tokenFilePath}`);
-            }
-            else {
-                console.error(`🔍 No token file found at: ${this.tokenFilePath}`);
-                this.token = null;
-            }
-        }
-        catch (error) {
-            console.error(`❌ Failed to load token from file: ${error}`);
-            this.token = null;
-        }
-    }
-    /**
-     * Saves the token to the file system
-     */
-    saveToken() {
-        try {
-            if (this.token) {
-                fs.writeFileSync(this.tokenFilePath, JSON.stringify(this.token, null, 2), 'utf8');
-                console.error(`✅ Saved token to file: ${this.tokenFilePath}`);
-            }
-            else {
-                // Remove the file if no token exists
-                if (fs.existsSync(this.tokenFilePath)) {
-                    fs.unlinkSync(this.tokenFilePath);
-                    console.error(`🗑️ Removed token file: ${this.tokenFilePath}`);
-                }
-            }
-        }
-        catch (error) {
-            console.error(`❌ Failed to save token to file: ${error}`);
-        }
-    }
     /**
      * Retrieves the cached token (ignores scopes since we use a global token)
      */
     getToken(scopes) {
-        // We ignore the scopes parameter since we use a single token with all scopes
+        // Scopes parameter ignored – single global token covers all requested scopes.
         return this.token;
     }
     /**
      * Stores the global token in the cache and persists it to file
      */
     setToken(scopes, token) {
-        // We ignore the scopes parameter since we use a single token with all scopes
         this.token = {
             access_token: token.access_token,
             refresh_token: token.refresh_token,
             expires_at: token.expires_in ? Date.now() + token.expires_in * 1000 : undefined,
-            scopes: [...scopes], // Store the actual scopes that were granted
+            scopes: [...scopes],
         };
-        this.saveToken();
     }
     /**
      * Removes the cached token and deletes the file
      */
     clearToken(scopes) {
-        // We ignore the scopes parameter since we use a single global token
         this.token = null;
-        this.saveToken();
     }
     /**
      * Checks if the token exists and is still valid (not expired)
      */
     isTokenValid(scopes) {
         // We ignore the scopes parameter since we use a single token with all scopes
-        if (!this.token) {
-            console.error(`🔍 Token validation: No token in cache`);
+        if (!this.token)
             return false;
-        }
-        // If no expiration time is set, assume token is valid
-        if (!this.token.expires_at) {
-            console.error(`🔍 Token validation: Token has no expiration, assuming valid`);
-            return true;
-        }
+        if (!this.token.expires_at)
+            return true; // treat as non-expiring
         // Add a 30-second buffer to avoid using tokens that are about to expire
         const bufferMs = 30 * 1000; // 30 seconds
         const now = Date.now();
         const expiresAt = this.token.expires_at;
-        const isValid = now + bufferMs < expiresAt;
-        return isValid;
+        return now + bufferMs < expiresAt;
     }
 }
-exports.FileTokenCache = FileTokenCache;
-// Global token cache instance - uses file-based persistence
-exports.globalTokenCache = new FileTokenCache();
+exports.InMemoryTokenCache = InMemoryTokenCache;
+// Global token cache instance - In-memory only
+exports.globalTokenCache = new InMemoryTokenCache();

package/dist/index.js

@@ -27,6 +27,7 @@ const getDynatraceEnv_1 = require("./getDynatraceEnv");
 const telemetry_openkit_1 = require("./utils/telemetry-openkit");
 const dynatrace_entity_types_1 = require("./utils/dynatrace-entity-types");
 const grail_budget_tracker_1 = require("./utils/grail-budget-tracker");
+const dynatrace_connection_utils_1 = require("./utils/dynatrace-connection-utils");
 // Load environment variables from .env file if available, and suppress warnings/logging to stdio
 // as it breaks MCP communication when using stdio transport
 const dotEnvOutput = (0, dotenv_1.config)({ quiet: true });
@@ -42,6 +43,7 @@ else {
     console.error(`.env file loaded successfully - loaded ${dotEnvOutput.parsed ? Object.keys(dotEnvOutput.parsed).length : 0} environment variables: ${Object.keys(dotEnvOutput.parsed || {}).join(', ')}`);
 }
 const DT_MCP_AUTH_CODE_FLOW_OAUTH_CLIENT_ID = 'dt0s08.dt-app-local'; // ToDo: Register our own oauth client
+// Base Scopes for MCP Server tools
 let scopesBase = [
     'app-engine:apps:run', // needed for environmentInformationClient
     'app-engine:functions:run', // needed for environmentInformationClient
@@ -53,7 +55,8 @@ const allRequiredScopes = scopesBase.concat([
     'storage:events:read', // Read events from Grail
     'storage:buckets:read', // Read all system data stored on Grail
     'storage:security.events:read', // Read Security events from Grail
-    'storage:entities:read', // Read Entities from Grail
+    'storage:entities:read', // Read classic Entities
+    'storage:smartscape:read', // Read Smartscape Entities from Grail
     'storage:logs:read', // Read logs for reliability guardian validations
     'storage:metrics:read', // Read metrics for reliability guardian validations
     'storage:bizevents:read', // Read bizevents for reliability guardian validations
@@ -74,57 +77,6 @@ const allRequiredScopes = scopesBase.concat([
     // Communication scopes
     'email:emails:send', // Send emails
 ]);
-/**
- * Performs a connection test to the Dynatrace environment.
- * Throws an error if the connection or authentication fails.
- */
-async function testDynatraceConnection(dtEnvironment, oauthClientId, oauthClientSecret, dtPlatformToken) {
-    const dtClient = await (0, dynatrace_clients_1.createDtHttpClient)(dtEnvironment, oauthClientId && !oauthClientSecret ? allRequiredScopes : scopesBase, oauthClientId, oauthClientSecret, dtPlatformToken);
-    const environmentInformationClient = new client_platform_management_service_1.EnvironmentInformationClient(dtClient);
-    // This call will fail if authentication is incorrect.
-    await environmentInformationClient.getEnvironmentInformation();
-}
-function handleClientRequestError(error) {
-    let additionalErrorInformation = '';
-    if (error.response.status === 403) {
-        additionalErrorInformation =
-            'Note: Your user or service-user is most likely lacking the necessary permissions/scopes for this API Call.';
-    }
-    return `Client Request Error: ${error.message} with HTTP status: ${error.response.status}. ${additionalErrorInformation} (body: ${JSON.stringify(error.body)})`;
-}
-/**
- * Try to connect to Dynatrace environment with retries and exponential backoff.
- */
-async function retryTestDynatraceConnection(dtEnvironment, oauthClientId, oauthClientSecret, dtPlatformToken) {
-    let retryCount = 0;
-    const maxRetries = 3; // Max retries
-    const delayMs = 2000; // Initial delay of 2 seconds
-    while (true) {
-        try {
-            console.error(`Testing connection to Dynatrace environment: ${dtEnvironment}... (Attempt ${retryCount + 1} of ${maxRetries})`);
-            await testDynatraceConnection(dtEnvironment, oauthClientId, oauthClientSecret, dtPlatformToken);
-            console.error(`Successfully connected to the Dynatrace environment at ${dtEnvironment}.`);
-            break;
-        }
-        catch (error) {
-            console.error(`Error: Could not connect to the Dynatrace environment at ${dtEnvironment}.`);
-            if ((0, shared_errors_1.isClientRequestError)(error)) {
-                console.error(handleClientRequestError(error));
-            }
-            else {
-                console.error(`Error: ${error.message}`);
-            }
-            retryCount++;
-            if (retryCount >= maxRetries) {
-                console.error(`Fatal: Maximum number of connection retries (${maxRetries}) exceeded. Exiting.`);
-                throw new Error(`Failed to connect to Dynatrace environment ${dtEnvironment} after ${maxRetries} attempts. Most likely your configuration is incorrect. Last error: ${error.message}`, { cause: error });
-            }
-            const delay = Math.pow(2, retryCount) * delayMs; // Exponential backoff
-            console.error(`Retrying in ${delay / 1000} seconds...`);
-            await new Promise((resolve) => setTimeout(resolve, delay));
-        }
-    }
-}
 const main = async () => {
     console.error(`Initializing Dynatrace MCP Server v${(0, version_1.getPackageJsonVersion)()}...`);
     // read Environment variables
@@ -144,20 +96,6 @@ const main = async () => {
         console.error('No OAuth credentials or platform token provided - switching to OAuth authorization code flow.');
         oauthClientId = DT_MCP_AUTH_CODE_FLOW_OAUTH_CLIENT_ID; // Default OAuth client ID for auth code flow
     }
-    // Test connection on startup
-    try {
-        // Depending on the authentication type, there are multiple pitfalls
-        // * For Platform Tokens, we can just try to access "get environment info" and we will know whether it works
-        // * For Oauth Client Credentials flow, we can also try to request an access token upfront with limited scopes, and verify whether everything works
-        // * for Oauth Auth Code flow, we can only verify whether the client ID is valid and the OAuth verifier call works, but we can't verify whether the user will be able to authenticate successfully
-        await retryTestDynatraceConnection(dtEnvironment, oauthClientId, oauthClientSecret, dtPlatformToken);
-    }
-    catch (err) {
-        console.error(err.message);
-        process.exit(2);
-    }
-    // Ready to start the server
-    console.error(`Starting Dynatrace MCP Server v${(0, version_1.getPackageJsonVersion)()}...`);
     // Initialize usage tracking
     const telemetry = (0, telemetry_openkit_1.createTelemetry)();
     await telemetry.trackMcpServerStart();
@@ -189,6 +127,51 @@ const main = async () => {
         return await (0, dynatrace_clients_1.createDtHttpClient)(dtEnvironment, oauthClientId && !oauthClientSecret ? allRequiredScopes : scopes, // Always use all scopes for maximum reusability
         oauthClientId, oauthClientSecret, dtPlatformToken);
     };
+    // Try to establish a Dynatrace connection upfront, to see if everything is configured properly
+    console.error(`Testing connection to Dynatrace environment: ${dtEnvironment}...`);
+    // First, we will try a simple "fetch" to connect to dtEnvironment, without authentication
+    // This should help to see if DNS lookup works, TCP connection can be established, and TLS handshake works
+    try {
+        const response = await fetch(`${dtEnvironment}`).then((response) => response.text());
+        // check response
+        if (response && response.length > 0) {
+            if (response.includes('Authentication required')) {
+                // all good - we reached the environment and authentication is required, which is going to be the next step
+            }
+            else {
+                console.error(`⚠️ Tried to contact ${dtEnvironment}, got the following response: ${response}`);
+                // Note: We won't error out yet, but this information could already be helpful for troubleshooting
+            }
+        }
+        else {
+            throw new Error('No response received');
+        }
+    }
+    catch (error) {
+        console.error(`❌ Failed to connect to Dynatrace environment ${dtEnvironment}:`, error.message);
+        console.error(error);
+        process.exit(3);
+    }
+    // Second, we will try with proper authentication
+    try {
+        const dtClient = await createAuthenticatedHttpClient(scopesBase);
+        const environmentInformationClient = new client_platform_management_service_1.EnvironmentInformationClient(dtClient);
+        await environmentInformationClient.getEnvironmentInformation();
+        console.error(`✅ Successfully connected to the Dynatrace environment at ${dtEnvironment}.`);
+    }
+    catch (error) {
+        if ((0, shared_errors_1.isClientRequestError)(error)) {
+            console.error(`❌ Failed to connect to Dynatrace environment ${dtEnvironment}:`, (0, dynatrace_connection_utils_1.handleClientRequestError)(error));
+        }
+        else {
+            console.error(`❌ Failed to connect to Dynatrace environment ${dtEnvironment}:`, error.message);
+            // Logging more exhaustive error details for troubleshooting
+            console.error(error);
+        }
+        process.exit(2);
+    }
+    // Ready to start the server
+    console.error(`Starting Dynatrace MCP Server v${(0, version_1.getPackageJsonVersion)()}...`);
     // quick abstraction/wrapper to make it easier for tools to reply text instead of JSON
     const tool = (name, description, paramsSchema, annotations, cb) => {
         const wrappedCb = async (args) => {
@@ -210,11 +193,11 @@ const main = async () => {
                 // check if it's an error originating from the Dynatrace SDK / API Gateway and provide an appropriate message to the user
                 if ((0, shared_errors_1.isClientRequestError)(error)) {
                     return {
-                        content: [{ type: 'text', text: handleClientRequestError(error) }],
+                        content: [{ type: 'text', text: (0, dynatrace_connection_utils_1.handleClientRequestError)(error) }],
                         isError: true,
                     };
                 }
-                // else: We don't know what kind of error happened - best-case we can provide error.message
+                // else: We don't know what kind of error happened - best case we can log the error and provide error.message as a tool response
                 console.log(error);
                 return {
                     content: [{ type: 'text', text: `Error: ${error.message}` }],

package/dist/utils/dynatrace-connection-utils.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleClientRequestError = handleClientRequestError;
+function handleClientRequestError(error) {
+    let additionalErrorInformation = '';
+    if (error.response.status === 403) {
+        additionalErrorInformation =
+            'Note: Your user or service-user is most likely lacking the necessary permissions/scopes for this API Call.';
+    }
+    return `Client Request Error: ${error.message} with HTTP status: ${error.response.status}. ${additionalErrorInformation} (body: ${JSON.stringify(error.body)})`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynatrace-oss/dynatrace-mcp-server",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "mcpName": "io.github.dynatrace-oss/Dynatrace-mcp",
   "description": "Model Context Protocol (MCP) server for Dynatrace",
   "keywords": [