Add MCP config management

Author: kshmidt-digma

README.md

@@ -1,27 +1,20 @@
-# Digma Continuous Feedback
+# Digma agentic AI SRE
 
-Digma is VS Code extension for automatically identifying and fixing performance issues in your code. It enables developers to find the root cause of bottlenecks, scaling problems and query issues in the code.
-
-## Example of issues Digma detects automatically
-
-- Bottlenecks and concurrency anti-patterns
-- Query inefficiencies
-- Scaling problems
-- N+1 Selects
-- Performance regressions
+Autonomous identification, root cause analysis and remediation of code and infrastructure issues
 
 For more info check out our [website](https://digma.ai)
 
 ## Extension settings
 
 This extension contributes the following settings:
 
-| Key              | Type   | Default                  | Description         |
-| ---------------- | ------ | ------------------------ | ------------------- |
-| `digma.apiUrl`   | string | `https://localhost:5051` | Digma API URL       |
-| `digma.apiToken` | string | -                        | Digma API token     |
-| `digma.login`    | string | -                        | Digma user login    |
-| `digma.password` | string | -                        | Digma user password |
+| Key                       | Type    | Default                  | Description                 |
+| ------------------------- | ------- | ------------------------ | --------------------------- |
+| `digma.url`               | string  | `https://localhost:5051` | API URL                     |
+| `digma.token`             | string  | -                        | API token                   |
+| `digma.login`             | string  | -                        | User login                  |
+| `digma.password`          | string  | -                        | User password               |
+| `digma.copySettingsToMcp` | boolean | false                    | Copy settings to MCP server |
 
 ## Build
 

package-lock.json

@@ -1,8 +1,8 @@
 {
   "name": "digma",
-  "displayName": "Digma Continuous Feedback",
-  "description": "Code insights and Observability for OpenTelemetry. .NET, Python, more coming soon.",
-  "version": "0.5.48",
+  "displayName": "Digma agentic AI SRE",
+  "description": "Autonomous identification, root cause analysis and remediation of code and infrastructure issues",
+  "version": "0.6.0",
   "publisher": "digma",
   "icon": "digma.png",
   "engines": {
@@ -73,23 +73,35 @@
   "contributes": {
     "configuration": {
       "properties": {
-        "digma.apiUrl": {
+        "digma.url": {
           "type": "string",
+          "title": "URL",
           "default": "https://localhost:5051",
-          "description": "Digma API URL"
+          "description": "API URL",
+          "order": 0
         },
-        "digma.apiToken": {
+        "digma.token": {
           "type": "string",
           "default": "",
-          "description": "Digma API token"
+          "description": "API token",
+          "order": 1
         },
         "digma.login": {
           "type": "string",
-          "description": "Digma user login"
+          "description": "User login",
+          "order": 2
         },
         "digma.password": {
           "type": "string",
-          "description": "Digma user password"
+          "description": "User password",
+          "order": 3
+        },
+        "digma.copySettingsToMcp": {
+          "type": "boolean",
+          "title": "Copy settings to MCP",
+          "default": false,
+          "description": "Copy settings to MCP server",
+          "order": 4
         }
       }
     }

package.json

@@ -0,0 +1,67 @@
+import vscode from "vscode";
+import type { PackageJSON } from "./types";
+
+export interface SettingDefinition {
+  key: string;
+  secret: boolean;
+}
+
+export type Settings = Record<string, string | undefined>;
+
+export class SettingsManager {
+  private static readonly SETTING_DEFINITIONS: SettingDefinition[] = [
+    { key: "url", secret: false },
+    { key: "token", secret: false },
+    { key: "login", secret: false },
+    { key: "password", secret: false },
+    { key: "copySettingsToMcp", secret: false }
+  ];
+
+  private context: vscode.ExtensionContext;
+  private extensionName: string;
+
+  constructor(context: vscode.ExtensionContext) {
+    this.context = context;
+    this.extensionName = (context.extension.packageJSON as PackageJSON).name;
+  }
+
+  async getSetting<T>(key: string): Promise<T | undefined> {
+    const settingDef = SettingsManager.SETTING_DEFINITIONS.find(
+      (s) => s.key === key
+    );
+
+    if (!settingDef) {
+      throw new Error(`Unknown setting: ${key}`);
+    }
+
+    if (settingDef.secret) {
+      const value = await this.context.secrets.get(
+        `${this.extensionName}.${key}`
+      );
+      return value ? (JSON.parse(value) as T) : undefined;
+    } else {
+      const config = vscode.workspace.getConfiguration(this.extensionName);
+      return config.get<T>(key);
+    }
+  }
+
+  async setSetting(key: string, value: unknown): Promise<void> {
+    const settingDef = SettingsManager.SETTING_DEFINITIONS.find(
+      (s) => s.key === key
+    );
+
+    if (!settingDef) {
+      throw new Error(`Unknown setting: ${key}`);
+    }
+
+    if (settingDef.secret) {
+      await this.context.secrets.store(
+        `${this.extensionName}.${key}`,
+        JSON.stringify(value)
+      );
+    } else {
+      const config = vscode.workspace.getConfiguration(this.extensionName);
+      await config.update(key, value);
+    }
+  }
+}

src/SettingsManager.ts

@@ -2,7 +2,8 @@ import express from "express";
 import net from "net";
 import vscode from "vscode";
 import { DigmaApiClient } from "./api/DigmaApiClient";
-import { getExtensionSettings } from "./settings";
+import { registerMcpServer } from "./registerMcpServer";
+import { SettingsManager } from "./SettingsManager";
 import type { PackageJSON } from "./types";
 import { attachIncidentFileToChatContext } from "./uris/handlers/context";
 import { UriRouter } from "./uris/UriRouter";
@@ -11,6 +12,7 @@ const START_PORT = 33100;
 const END_PORT = 33199;
 
 let digmaClient: DigmaApiClient | null = null;
+// let mcpServerDisposable: vscode.Disposable | null = null;
 
 const findAvailablePort = async (
   start: number,
@@ -37,35 +39,22 @@ const isPortAvailable = (port: number): Promise<boolean> => {
 async function initializeClient(
   context: vscode.ExtensionContext
 ): Promise<void> {
-  const { apiUrl, apiToken, login, password } = getExtensionSettings(context);
+  const settingsManager = new SettingsManager(context);
 
-  if (!apiUrl) {
-    vscode.window.showErrorMessage(
-      "Digma API URL is not configured. Please set it in the extension settings."
-    );
-    return;
-  }
-
-  if (!apiToken) {
-    vscode.window.showWarningMessage(
-      "API token is not configured. Please set it in the extension settings."
-    );
-    return;
-  }
+  const url = await settingsManager.getSetting<string>("url");
+  const token = await settingsManager.getSetting<string>("token");
+  const login = await settingsManager.getSetting<string>("login");
+  const password = await settingsManager.getSetting<string>("password");
 
-  if (!login || !password) {
-    vscode.window.showErrorMessage(
-      "Digma login credentials are not configured. Please set them in the extension settings."
-    );
+  if (!token || !url || !login || !password) {
     return;
   }
 
   // Initialize the client
-  digmaClient = new DigmaApiClient(apiUrl, apiToken);
+  digmaClient = new DigmaApiClient(url, token);
 
   try {
-    await digmaClient.login({ username: login, password });
-    vscode.window.showInformationMessage("Successfully logged in to Digma.");
+    await digmaClient.login({ username: login, password: password });
   } catch (error) {
     // eslint-disable-next-line no-console
     console.error("Digma login failed:", error);
@@ -92,9 +81,36 @@ export async function activate(context: vscode.ExtensionContext) {
   const configChangeListener = vscode.workspace.onDidChangeConfiguration(
     async (event) => {
       const extensionName = (context.extension.packageJSON as PackageJSON).name;
-      if (event.affectsConfiguration(extensionName)) {
+      if (
+        event.affectsConfiguration(`${extensionName}.url`) ||
+        event.affectsConfiguration(`${extensionName}.token`) ||
+        event.affectsConfiguration(`${extensionName}.login`) ||
+        event.affectsConfiguration(`${extensionName}.password`)
+      ) {
+        const settingsManager = new SettingsManager(context);
+        await settingsManager.setSetting("copySettingsToMcp", false);
+
         await initializeClient(context);
       }
+
+      // Update MCP server configuration
+      if (event.affectsConfiguration(`${extensionName}.copySettingsToMcp`)) {
+        const settingsManager = new SettingsManager(context);
+        const url = await settingsManager.getSetting<string>("url");
+        const token = await settingsManager.getSetting<string>("token");
+        const copySettingsToMcp =
+          await settingsManager.getSetting<boolean>("copySettingsToMcp");
+
+        if (copySettingsToMcp && url && token) {
+          try {
+            registerMcpServer(url, token);
+          } catch (error) {
+            // eslint-disable-next-line no-console
+            console.error("MCP server registration failed:", error);
+            vscode.window.showErrorMessage("Failed to register MCP server.");
+          }
+        }
+      }
     }
   );
 
@@ -165,6 +181,11 @@ export function deactivate() {
   if (digmaClient) {
     digmaClient = null;
   }
+
+  // if (mcpServerDisposable) {
+  //   mcpServerDisposable.dispose();
+  //   mcpServerDisposable = null;
+  // }
 }
 
 export function getDigmaClient(): DigmaApiClient {

src/extension.ts

@@ -0,0 +1,21 @@
+import vscode from "vscode";
+
+export const getIdeFolderUri = (ideName: string): vscode.Uri | undefined => {
+  if (
+    !vscode.workspace.workspaceFolders ||
+    vscode.workspace.workspaceFolders.length === 0
+  ) {
+    throw new Error("No workspace found");
+  }
+
+  const workspaceFolder = vscode.workspace.workspaceFolders[0];
+
+  switch (ideName) {
+    case "Visual Studio Code":
+      return vscode.Uri.joinPath(workspaceFolder.uri, ".vscode");
+    case "Cursor":
+      return vscode.Uri.joinPath(workspaceFolder.uri, ".cursor");
+    default:
+      throw new Error(`Unsupported IDE: ${ideName}`);
+  }
+};