@dynatrace-oss/dynatrace-mcp-server 0.3.0 → 0.5.0-rc.1

package/README.md

@@ -7,10 +7,10 @@ Bring real-time observability data directly into your development workflow.
 
 ## Use cases
 
-- Real-time observability, fetch production-level data for early detection.
-- Fix issues in the context from monitored exceptions, logs, and anomalies.
-- More context on security level issues
-- Natural language to query log data
+- **Real-time observability** - Fetch production-level data for early detection and proactive monitoring
+- **Contextual debugging** - Fix issues with full context from monitored exceptions, logs, and anomalies
+- **Security insights** - Get detailed vulnerability analysis and security problem tracking
+- **Natural language queries** - Use AI-powered DQL generation and explanation
 
 ## Capabilities
 
@@ -22,9 +22,16 @@ Bring real-time observability data directly into your development workflow.
 - Get more information about a monitored entity
 - Get Ownership of an entity
 
-## Quickstart
+### AI-Powered Assistance (Preview)
+
+- **Natural Language to DQL** - Convert plain English queries to Dynatrace Query Language
+- **DQL Explanation** - Get plain English explanations of complex DQL queries
+- **AI Chat Assistant** - Get contextual help and guidance for Dynatrace questions
+- **Feedback System** - Provide feedback to improve AI responses over time
 
-**Work in progress**
+> **Note:** While Davis CoPilot AI is generally available (GA), the Davis CoPilot APIs are currently in preview. For more information, visit the [Davis CoPilot Preview Community](https://dt-url.net/copilot-community).
+
+## Quickstart
 
 You can add this MCP server (using STDIO) to your MCP Client like VS Code, Claude, Cursor, Amazon Q Developer CLI, Windsurf Github Copilot via the package `@dynatrace-oss/dynatrace-mcp-server`.
 
@@ -106,76 +113,113 @@ This configuration should be stored in `<your-repo>/.amazonq/mcp.json`.
 
 ## Environment Variables
 
-A **Dynatrace OAuth Client** is needed to communicate with your Dynatrace Environment. Please follow the documentation about
-[creating an Oauth Client in Dynatrace](https://docs.dynatrace.com/docs/manage/identity-access-management/access-tokens-and-oauth-clients/oauth-clients),
-and set up the following environment variables in order for this MCP to work:
-
-* `DT_ENVIRONMENT` (string, e.g., https://abc12345.apps.dynatrace.com) - URL to your Dynatrace Platform (do not use Dynatrace classic URLs like `abc12345.live.dynatrace.com`)
-* `OAUTH_CLIENT_ID` (string, e.g., `dt0s02.SAMPLE`) - Dynatrace OAuth Client ID
-* `OAUTH_CLIENT_SECRET` (string, e.g., `dt0s02.SAMPLE.abcd1234`) - Dynatrace OAuth Client Secret
-* OAuth Client Scopes:
-  * `app-engine:apps:run` - needed for environmentInformationClient
-  * `app-engine:functions:run` - needed for environmentInformationClient
-  * `hub:catalog:read` - get details about installed Apps on Dynatrace Environment
-  * `environment-api:security-problems:read` - needed for reading security problems
-  * `environment-api:entities:read` - read monitored entities
-  * `environment-api:problems:read` - get problems
-  * `environment-api:metrics:read` - read metrics
-  * `environment-api:slo:read` - read SLOs
-  * `storage:buckets:read` - Read all system data stored on 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
-  * `storage:spans:read` - Read spans from Grail
-  * `storage:entities:read` - Read Entities from Grail
-  * `storage:events:read` -  Read Events from Grail
-  * `storage:system:read` - Read System Data from Grail
-  * `storage:user.events:read` - Read User events from Grail
-  * `storage:user.sessions:read` - Read User sessions from Grail
-  * `settings:objects:read` - needed for reading ownership information and Guardians (SRG) from settings
-
-    **Note**: Please ensure that `settings:objects:read` is used, and *not* the similarly named scope `app-settings:objects:read`.
+You can set up authentication via **OAuth Client** or **Platform Tokens** (v0.5.0 and newer) via the following environment variables:
+
+- `DT_ENVIRONMENT` (string, e.g., https://abc12345.apps.dynatrace.com) - URL to your Dynatrace Platform (do not use Dynatrace classic URLs like `abc12345.live.dynatrace.com`)
+- `OAUTH_CLIENT_ID` (string, e.g., `dt0s02.SAMPLE`) - Dynatrace OAuth Client ID
+- `OAUTH_CLIENT_SECRET` (string, e.g., `dt0s02.SAMPLE.abcd1234`) - Dynatrace OAuth Client Secret
+- With v0.5.0 and newer: `DT_PLATFORM_TOKEN` (string, e.g., `dt0s16.SAMPLE.abcd1234`) - Dynatrace Platform Token (limited support, as not all scopes are available; see below)
+
+For more information, please have a look at the documentation about
+[creating an Oauth Client in Dynatrace](https://docs.dynatrace.com/docs/manage/identity-access-management/access-tokens-and-oauth-clients/oauth-clients), as well as
+[creating a Platform Token in Dynatrace](https://docs.dynatrace.com/docs/manage/identity-access-management/access-tokens-and-oauth-clients/platform-tokens).
 
 In addition, depending on the features you use, the following variables can be configured:
 
-* `SLACK_CONNECTION_ID` (string) - connection ID of a [Slack Connection](https://docs.dynatrace.com/docs/analyze-explore-automate/workflows/actions/slack)
-* `USE_APP_SETTINGS`  (boolean, `true` or `false`; default: `false`)
-  * Requires scope `app-settings:objects:read` to read settings-objects from app settings
-* `USE_WORKFLOWS` (boolean, `true` or `false`; default: `false`)
-  * Requires scopes `automation:workflows:read`, `automation:workflows:write` and `automation:workflows:run` to read, write and execute Workflows
+- `SLACK_CONNECTION_ID` (string) - connection ID of a [Slack Connection](https://docs.dynatrace.com/docs/analyze-explore-automate/workflows/actions/slack)
+
+### Scopes for Authentication
+
+Depending on the features you are using, the following scopes are needed:
+
+- `app-engine:apps:run` - needed for almost all tools
+- `app-engine:functions:run` - needed for for almost all tools
+- `environment-api:security-problems:read` - needed for reading security problems (_currently not available for Platform Tokens_)
+- `environment-api:entities:read` - read monitored entities (_currently not available for Platform Tokens_)
+- `environment-api:problems:read` - get problems (_currently not available for Platform Tokens_)
+- `environment-api:metrics:read` - read metrics (_currently not available for Platform Tokens_)
+- `environment-api:slo:read` - read SLOs (_currently not available for Platform Tokens_)
+- `automation:workflows:read` - read Workflows
+- `automation:workflows:write` - create and update Workflows
+- `automation:workflows:run` - run Workflows
+- `storage:buckets:read` - needed for `execute_dql` tool to read all system data stored on Grail
+- `storage:logs:read` - needed for `execute_dql` tool to read logs for reliability guardian validations
+- `storage:metrics:read` - needed for `execute_dql` tool to read metrics for reliability guardian validations
+- `storage:bizevents:read` - needed for `execute_dql` tool to read bizevents for reliability guardian validations
+- `storage:spans:read` - needed for `execute_dql` tool to read spans from Grail
+- `storage:entities:read` - needed for `execute_dql` tool to read Entities from Grail
+- `storage:events:read` - needed for `execute_dql` tool to read Events from Grail
+- `storage:security.events:read`- needed for `execute_dql` tool to read Security Events from Grail
+- `storage:system:read` - needed for `execute_dql` tool to read System Data from Grail
+- `storage:user.events:read` - needed for `execute_dql` tool to read User events from Grail
+- `storage:user.sessions:read` - needed for `execute_dql` tool to read User sessions from Grail
+- `davis-copilot:conversations:execute` - execute conversational skill (chat with Copilot)
+- `davis-copilot:nl2dql:execute` - execute Davis Copilot Natural Language (NL) to DQL skill
+- `davis-copilot:dql2nl:execute` - execute DQL to Natural Language (NL) skill
+- `settings:objects:read` - needed for reading ownership information and Guardians (SRG) from settings
+
+  **Note**: Please ensure that `settings:objects:read` is used, and _not_ the similarly named scope `app-settings:objects:read`.
 
 ## ✨ Example prompts ✨
 
 Use these example prompts as a starting point. Just copy them into your IDE or agent setup, adapt them to your services/stack/architecture,
 and extend them as needed. They’re here to help you imagine how real-time observability and automation work together in the MCP context in your IDE.
 
+**Write a DQL query from natural language:**
+
+```
+Show me error rates for the payment service in the last hour
+```
+
+**Explain a DQL query:**
+
+```
+What does this DQL do?
+fetch logs | filter dt.source_entity == 'SERVICE-123' | summarize count(), by:{severity} | sort count() desc
+```
+
+**Chat with Davis CoPilot:**
+
+```
+How can I investigate slow database queries in Dynatrace?
+```
+
 **Find open vulnerabilities on production, setup alert.**
+
 ```
 I have this code snippet here in my IDE, where I get a dependency vulnerability warning for my code.
 Check if I see any open vulnerability/cve on production.
 Analyze a specific production problem.
 Setup a workflow that sends Slack alerts to the #devops-alerts channel when availability problems occur.
 ```
+
 **Debug intermittent 503 errors.**
+
 ```
 Our load balancer is intermittently returning 503 errors during peak traffic.
 Pull all recent problems detected for our front-end services and
 run a query to correlate error rates with service instance health indicators.
 I suspect we have circuit breakers triggering, but need confirmation from the telemetry data.
 ```
+
 **Correlate memory issue with logs.**
+
 ```
 There's a problem with high memory usage on one of our hosts.
 Get the problem details and then fetch related logs to help understand
 what's causing the memory spike? Which file in this repo is this related to?
 ```
+
 **Trace request flow analysis.**
+
 ```
 Our users are experiencing slow checkout processes.
 Can you execute a DQL query to show me the full request trace for our checkout flow,
 so I can identify which service is causing the bottleneck?
 ```
+
 **Analyze Kubernetes cluster events.**
+
 ```
 Our application deployments seem to be failing intermittently.
 Can you fetch recent events from our "production-cluster"
@@ -194,6 +238,7 @@ In case of any problems, you can troubleshoot SSO/OAuth issues based on our [Dyn
 It is recommended to try access the following API (which requires minimal scopes `app-engine:apps:run` and `app-engine:functions:run`):
 
 1. Use OAuth Client ID and Secret to retrieve a Bearer Token (only valid for a couple of minutes):
+
 ```bash
 curl --request POST 'https://sso.dynatrace.com/sso/oauth2/token' \
   --header 'Content-Type: application/x-www-form-urlencoded' \
@@ -204,6 +249,7 @@ curl --request POST 'https://sso.dynatrace.com/sso/oauth2/token' \
 ```
 
 2. Use `access_token` from the response of the above call as the bearer-token in the next call:
+
 ```bash
 curl -X GET https://abc12345.apps.dynatrace.com/platform/management/v1/environment \
   -H 'accept: application/json' \
@@ -211,6 +257,7 @@ curl -X GET https://abc12345.apps.dynatrace.com/platform/management/v1/environme
 ```
 
 3. You should retrieve a result like this:
+
 ```json
 {
   "environmentId": "abc12345",
@@ -220,35 +267,32 @@ curl -X GET https://abc12345.apps.dynatrace.com/platform/management/v1/environme
 }
 ```
 
-
 ### Problem accessing data on Grail
 
 Grail has a dedicated section about permissions in the Dynatrace Docs. Please refer to https://docs.dynatrace.com/docs/discover-dynatrace/platform/grail/data-model/assign-permissions-in-grail for more details.
 
-
 ## Development
 
 For local development purposes, you can use VSCode and GitHub Copilot.
 
 First, enable Copilot for your Workspace `.vscode/settings.json`:
+
 ```json
 {
   "github.copilot.enable": {
     "*": true
   }
 }
-
 ```
 
 Second, add the MCP to `.vscode/mcp.json`:
+
 ```json
 {
   "servers": {
     "my-dynatrace-mcp-server": {
       "command": "node",
-      "args": [
-        "${workspaceFolder}/dist/index.js"
-      ],
+      "args": ["${workspaceFolder}/dist/index.js"],
       "envFile": "${workspaceFolder}/.env"
     }
   }
@@ -259,7 +303,7 @@ Third, create a `.env` file in this repository (you can copy from `.env.template
 
 Last but not least, switch to Agent Mode in CoPilot and reload tools.
 
-
 ## Notes
+
 This product is not officially supported by Dynatrace.
 Please contact us via [GitHub Issues](https://github.com/dynatrace-oss/dynatrace-mcp/issues) if you have feature requests, questions, or need help.

package/dist/authentication/dynatrace-clients.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDtHttpClient = void 0;
+const http_client_1 = require("@dynatrace-sdk/http-client");
+const dt_app_1 = require("dt-app");
+const package_json_1 = require("../../package.json");
+/**
+ * Uses the provided oauth Client ID and Secret and requests a token via client-credentials flow
+ * @param clientId - OAuth Client ID for Dynatrace
+ * @param clientSecret - Oauth Client Secret for Dynatrace
+ * @param ssoAuthUrl - SSO Authentication URL
+ * @param scopes - List of requested scopes
+ * @returns
+ */
+const requestToken = async (clientId, clientSecret, ssoAuthUrl, scopes) => {
+    const res = await fetch(ssoAuthUrl, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/x-www-form-urlencoded',
+        },
+        body: new URLSearchParams({
+            grant_type: 'client_credentials',
+            client_id: clientId,
+            client_secret: clientSecret,
+            scope: scopes.join(' '),
+        }),
+    });
+    // check if the response was okay (HTTP 2xx) or not (HTTP 4xx or 5xx)
+    if (!res.ok) {
+        // log the error
+        console.error(`Failed to fetch token: ${res.status} ${res.statusText}`);
+    }
+    // and return the JSON result, as it contains additional information
+    return await res.json();
+};
+/**
+ * Create a Dynatrace Http Client (from the http-client SDK) based on the provided authentication credentails
+ * @param environmentUrl
+ * @param scopes
+ * @param clientId
+ * @param clientSecret
+ * @param dtPlatformToken
+ * @returns
+ */
+const createDtHttpClient = async (environmentUrl, scopes, clientId, clientSecret, dtPlatformToken) => {
+    if (clientId && clientSecret) {
+        // create an OAuth client if clientId and clientSecret are provided
+        return createOAuthHttpClient(environmentUrl, scopes, clientId, clientSecret);
+    }
+    if (dtPlatformToken) {
+        // create a simple HTTP client if only the platform token is provided
+        return createBearerTokenHttpClient(environmentUrl, dtPlatformToken);
+    }
+    throw new Error('Failed to create Dynatrace HTTP Client: Please provide either clientId and clientSecret or dtPlatformToken');
+};
+exports.createDtHttpClient = createDtHttpClient;
+/** Creates an HTTP Client based on environmentUrl and a platform token */
+const createBearerTokenHttpClient = async (environmentUrl, dtPlatformToken) => {
+    return new http_client_1.PlatformHttpClient({
+        baseUrl: environmentUrl,
+        defaultHeaders: {
+            'Authorization': `Bearer ${dtPlatformToken}`,
+            'User-Agent': `dynatrace-mcp-server/v${package_json_1.version} (${process.platform}-${process.arch})`,
+        },
+    });
+};
+/** Create an Oauth Client based on clientId, clientSecret, environmentUrl and scopes
+ * This uses a client-credentials flow to request a token from the SSO endpoint.
+ */
+const createOAuthHttpClient = async (environmentUrl, scopes, clientId, clientSecret) => {
+    if (!clientId) {
+        throw new Error('Failed to retrieve OAuth client id from env "DT_APP_OAUTH_CLIENT_ID"');
+    }
+    if (!clientSecret) {
+        throw new Error('Failed to retrieve OAuth client secret from env "DT_APP_OAUTH_CLIENT_SECRET"');
+    }
+    if (!environmentUrl) {
+        throw new Error('Failed to retrieve environment URL from env "DT_ENVIRONMENT"');
+    }
+    console.error(`Trying to authenticate API Calls to ${environmentUrl} via OAuthClientId ${clientId} with the following scopes: ${scopes.join(', ')}`);
+    const ssoBaseUrl = await (0, dt_app_1.getSSOUrl)(environmentUrl);
+    const ssoAuthUrl = new URL('/sso/oauth2/token', ssoBaseUrl).toString();
+    console.error(`Using SSO auth URL: ${ssoAuthUrl}`);
+    // try to request a token, just to verify that everything is set up correctly
+    const tokenResponse = await requestToken(clientId, clientSecret, ssoAuthUrl, scopes);
+    // in case we didn't get a token, or error / error_description / issueId is set, we throw an error
+    if (!tokenResponse.access_token || tokenResponse.error || tokenResponse.error_description || tokenResponse.issueId) {
+        throw new Error(`Failed to retrieve OAuth token (IssueId: ${tokenResponse.issueId}): ${tokenResponse.error} - ${tokenResponse.error_description}. Note: Your OAuth client is most likely not configured correctly and/or is missing scopes.`);
+    }
+    console.error(`Successfully retrieved token from SSO!`);
+    return createBearerTokenHttpClient(environmentUrl, tokenResponse.access_token);
+};

package/dist/authentication/dynatrace-clients.test.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const dynatrace_clients_1 = require("./dynatrace-clients");
+const http_client_1 = require("@dynatrace-sdk/http-client");
+const dt_app_1 = require("dt-app");
+// Mock external dependencies
+jest.mock('@dynatrace-sdk/http-client');
+jest.mock('dt-app');
+jest.mock('../../package.json', () => ({
+    version: '1.0.0-test',
+}));
+// Mock fetch globally
+global.fetch = jest.fn();
+const mockPlatformHttpClient = http_client_1.PlatformHttpClient;
+const mockGetSSOUrl = dt_app_1.getSSOUrl;
+const mockFetch = global.fetch;
+describe('dynatrace-clients', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        // Reset console.error mock
+        jest.spyOn(console, 'error').mockImplementation(() => { });
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    describe('createDtHttpClient', () => {
+        const environmentUrl = 'https://test123.apps.dynatrace.com';
+        const scopes = ['scope1', 'scope2'];
+        describe('with OAuth credentials', () => {
+            const clientId = 'test-client-id';
+            const clientSecret = 'test-client-secret';
+            const platformToken = 'test-platform-token';
+            beforeEach(() => {
+                mockGetSSOUrl.mockResolvedValue('https://sso.dynatrace.com');
+            });
+            it('should create OAuth client successfully', async () => {
+                const mockTokenResponse = {
+                    access_token: 'test-access-token',
+                    token_type: 'Bearer',
+                    expires_in: 3600,
+                    scope: 'scope1 scope2',
+                };
+                mockFetch.mockResolvedValueOnce({
+                    ok: true,
+                    json: async () => mockTokenResponse,
+                });
+                const result = await (0, dynatrace_clients_1.createDtHttpClient)(environmentUrl, scopes, clientId, clientSecret);
+                expect(mockGetSSOUrl).toHaveBeenCalledWith(environmentUrl);
+                expect(mockFetch).toHaveBeenCalledWith('https://sso.dynatrace.com/sso/oauth2/token', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/x-www-form-urlencoded',
+                    },
+                    body: new URLSearchParams({
+                        grant_type: 'client_credentials',
+                        client_id: clientId,
+                        client_secret: clientSecret,
+                        scope: scopes.join(' '),
+                    }),
+                });
+                expect(mockPlatformHttpClient).toHaveBeenCalledWith({
+                    baseUrl: environmentUrl,
+                    defaultHeaders: {
+                        'Authorization': 'Bearer test-access-token',
+                        'User-Agent': 'dynatrace-mcp-server/v1.0.0-test (linux-x64)',
+                    },
+                });
+                expect(result).toBeInstanceOf(http_client_1.PlatformHttpClient);
+            });
+            it('should throw error when clientId, clientSecret and platformToken are missing', async () => {
+                await expect((0, dynatrace_clients_1.createDtHttpClient)(environmentUrl, scopes, undefined, undefined, undefined)).rejects.toThrow('Failed to create Dynatrace HTTP Client: Please provide either clientId and clientSecret or dtPlatformToken');
+            });
+            it('should throw error when environmentUrl is missing', async () => {
+                await expect((0, dynatrace_clients_1.createDtHttpClient)('', scopes, clientId, clientSecret)).rejects.toThrow('Failed to retrieve environment URL from env "DT_ENVIRONMENT"');
+            });
+            it('should throw error when token request fails with HTTP error', async () => {
+                mockFetch.mockResolvedValueOnce({
+                    ok: false,
+                    status: 401,
+                    statusText: 'Unauthorized',
+                    json: async () => ({
+                        error: 'invalid_client',
+                        error_description: 'Invalid client credentials',
+                    }),
+                });
+                await expect((0, dynatrace_clients_1.createDtHttpClient)(environmentUrl, scopes, clientId, clientSecret)).rejects.toThrow('Failed to retrieve OAuth token');
+                expect(console.error).toHaveBeenCalledWith('Failed to fetch token: 401 Unauthorized');
+            });
+            it('should throw error when token response contains error', async () => {
+                const mockErrorResponse = {
+                    error: 'invalid_scope',
+                    error_description: 'The requested scope is invalid',
+                    issueId: 'issue-123',
+                };
+                mockFetch.mockResolvedValueOnce({
+                    ok: true,
+                    json: async () => mockErrorResponse,
+                });
+                await expect((0, dynatrace_clients_1.createDtHttpClient)(environmentUrl, scopes, clientId, clientSecret)).rejects.toThrow('Failed to retrieve OAuth token (IssueId: issue-123): invalid_scope - The requested scope is invalid');
+            });
+            it('should throw error when token response is missing access_token', async () => {
+                const mockIncompleteResponse = {
+                    token_type: 'Bearer',
+                    expires_in: 3600,
+                };
+                mockFetch.mockResolvedValueOnce({
+                    ok: true,
+                    json: async () => mockIncompleteResponse,
+                });
+                await expect((0, dynatrace_clients_1.createDtHttpClient)(environmentUrl, scopes, clientId, clientSecret)).rejects.toThrow('Failed to retrieve OAuth token');
+            });
+            it('should log authentication details', async () => {
+                const mockTokenResponse = {
+                    access_token: 'test-access-token',
+                    token_type: 'Bearer',
+                    expires_in: 3600,
+                };
+                mockFetch.mockResolvedValueOnce({
+                    ok: true,
+                    json: async () => mockTokenResponse,
+                });
+                await (0, dynatrace_clients_1.createDtHttpClient)(environmentUrl, scopes, clientId, clientSecret);
+                expect(console.error).toHaveBeenCalledWith(`Trying to authenticate API Calls to ${environmentUrl} via OAuthClientId ${clientId} with the following scopes: ${scopes.join(', ')}`);
+            });
+        });
+        describe('with Bearer token', () => {
+            const dtPlatformToken = 'test-platform-token';
+            it('should create Bearer token client successfully', async () => {
+                const result = await (0, dynatrace_clients_1.createDtHttpClient)(environmentUrl, scopes, undefined, undefined, dtPlatformToken);
+                expect(mockPlatformHttpClient).toHaveBeenCalledWith({
+                    baseUrl: environmentUrl,
+                    defaultHeaders: {
+                        'Authorization': `Bearer ${dtPlatformToken}`,
+                        'User-Agent': 'dynatrace-mcp-server/v1.0.0-test (linux-x64)',
+                    },
+                });
+                expect(result).toBeInstanceOf(http_client_1.PlatformHttpClient);
+            });
+        });
+        describe('with no authentication', () => {
+            it('should throw error when no authentication method is provided', async () => {
+                await expect((0, dynatrace_clients_1.createDtHttpClient)(environmentUrl, scopes)).rejects.toThrow('Failed to create Dynatrace HTTP Client: Please provide either clientId and clientSecret or dtPlatformToken');
+            });
+        });
+    });
+    describe('requestToken function (indirectly tested)', () => {
+        it('should handle fetch errors gracefully', async () => {
+            mockGetSSOUrl.mockResolvedValue('https://sso.dynatrace.com');
+            // Mock fetch to throw an error
+            mockFetch.mockRejectedValueOnce(new Error('Network error'));
+            await expect((0, dynatrace_clients_1.createDtHttpClient)('https://test.apps.dynatrace.com', ['scope1'], 'client-id', 'client-secret')).rejects.toThrow('Network error');
+        });
+        it('should format request body correctly', async () => {
+            mockGetSSOUrl.mockResolvedValue('https://sso.dynatrace.com');
+            const mockTokenResponse = {
+                access_token: 'test-token',
+            };
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => mockTokenResponse,
+            });
+            await (0, dynatrace_clients_1.createDtHttpClient)('https://test.apps.dynatrace.com', ['scope1', 'scope2'], 'test-client', 'test-secret');
+            const expectedBody = new URLSearchParams({
+                grant_type: 'client_credentials',
+                client_id: 'test-client',
+                client_secret: 'test-secret',
+                scope: 'scope1 scope2',
+            });
+            expect(mockFetch).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                },
+                body: expectedBody,
+            }));
+        });
+    });
+    describe('User-Agent header', () => {
+        it('should include correct User-Agent format', async () => {
+            const dtPlatformToken = 'test-token';
+            await (0, dynatrace_clients_1.createDtHttpClient)('https://test.apps.dynatrace.com', ['scope1'], undefined, undefined, dtPlatformToken);
+            expect(mockPlatformHttpClient).toHaveBeenCalledWith(expect.objectContaining({
+                defaultHeaders: expect.objectContaining({
+                    'User-Agent': expect.stringMatching(/^dynatrace-mcp-server\/v\d+\.\d+\.\d+(-\w+)? \(\w+-\w+\)$/),
+                }),
+            }));
+        });
+    });
+});

package/dist/authentication/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/capabilities/call-app-function.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callAppFunction = void 0;
+/** Helper function to call an app-function via platform-api */
+const callAppFunction = async (dtClient, appId, functionName, payload) => {
+    console.error(`Sending payload ${JSON.stringify(payload)}`);
+    const response = await dtClient.send({
+        url: `/platform/app-engine/app-functions/v1/apps/${appId}/api/${functionName}`,
+        method: 'POST',
+        headers: {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+        },
+        body: payload,
+        statusValidator: (status) => {
+            return [200].includes(status);
+        },
+    });
+    return await response.body('json');
+};
+exports.callAppFunction = callAppFunction;

package/dist/capabilities/create-workflow-for-problem-notification.js

@@ -12,18 +12,18 @@ const createWorkflowForProblemNotification = async (dtClient, teamName, channel,
         slowdown: false,
         resource: false,
         custom: false,
-        info: false
+        info: false,
     };
     // default trigger config
     let triggerConfig = {
         type: 'event',
         value: {
             eventType: 'events',
-            query: ''
-        }
+            query: '',
+        },
     };
     // special case: Security Problems
-    if (problemType.toUpperCase().indexOf("SECURITY") !== -1) {
+    if (problemType.toUpperCase().indexOf('SECURITY') !== -1) {
         triggerConfig.value.query = `event.kind=="SECURITY_EVENT"
         and event.type=="VULNERABILITY_STATUS_CHANGE_EVENT"
         and event.level == "ENTITY"
@@ -65,8 +65,8 @@ const createWorkflowForProblemNotification = async (dtClient, teamName, channel,
         triggerConfig = {
             type: 'davis-problem',
             value: {
-                categories
-            }
+                categories,
+            },
         };
     }
     let notificationWorkflow = {
@@ -76,28 +76,28 @@ const createWorkflowForProblemNotification = async (dtClient, teamName, channel,
         type: 'SIMPLE',
         // define the send_notification task
         tasks: {
-            "send_notification": {
-                name: "Send notification",
-                action: "dynatrace.slack:slack-send-message",
-                description: "Sends a notification to a Slack channel",
+            send_notification: {
+                name: 'Send notification',
+                action: 'dynatrace.slack:slack-send-message',
+                description: 'Sends a notification to a Slack channel',
                 input: {
-                    connectionId: "slack-connection-id",
+                    connectionId: 'slack-connection-id',
                     channel: `{{ \"${channel}\" }}`,
                     message: `🚨 Alert for Team ${teamName}\n*Problem Type*: ${problemType}\n*Problem ID*: {{ event()["display_id"] }}\n*Status*: {{ event()["event.status"] }}\n\n<{{ environment().url }}/ui/apps/dynatrace.davis.problems/problem/{{ event()["event.id"] }}|Click here for details>`,
                 },
                 active: true,
-            }
+            },
         },
         // define a trigger
         trigger: {
             eventTrigger: {
                 isActive: true,
                 triggerConfiguration: triggerConfig,
-            }
-        }
+            },
+        },
     };
     return await workflowsclient.createWorkflow({
-        body: notificationWorkflow
+        body: notificationWorkflow,
     });
 };
 exports.createWorkflowForProblemNotification = createWorkflowForProblemNotification;