@mithung/vunet-mcp-server 2.0.0

package/index.js

@@ -0,0 +1,558 @@
+#!/usr/bin/env node
+
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+import axios from "axios";
+import https from "https";
+
+/**
+ * Vunet MCP Server
+ * Connects to Vunet vuSmartMaps using environment variables (similar to Dynatrace MCP)
+ * 
+ * Environment Variables:
+ * - VUNET_TENANT_URL: Vunet tenant URL (required)
+ * - VUNET_USERNAME: Username for authentication (required)
+ * - VUNET_PASSWORD: Password for authentication (required)
+ * - VUNET_BU_ID: Business Unit ID (optional, default: "1")
+ * - VUNET_VERIFY_SSL: SSL verification (optional, default: "true")
+ */
+
+class VunetMCPServer {
+  constructor() {
+    this.server = new Server(
+      {
+        name: "vunet-mcp-server",
+        version: "2.0.0",
+      },
+      {
+        capabilities: {
+          tools: {},
+        },
+      }
+    );
+
+    // Configuration from environment variables
+    this.tenantUrl = process.env.VUNET_TENANT_URL;
+    this.username = process.env.VUNET_USERNAME;
+    this.password = process.env.VUNET_PASSWORD;
+    this.buId = process.env.VUNET_BU_ID || "1";
+    this.bearerToken = process.env.VUNET_BEARER_TOKEN;
+    
+    // Session state
+    this.sessionToken = null;
+    this.sessionExpiry = null;
+    this.isAuthenticated = false;
+
+    // HTTPS agent for SSL handling
+    const verifySSL = process.env.VUNET_VERIFY_SSL !== "false";
+    this.httpsAgent = new https.Agent({
+      rejectUnauthorized: verifySSL,
+    });
+
+    this.setupHandlers();
+    this.setupErrorHandling();
+  }
+
+  setupErrorHandling() {
+    this.server.onerror = (error) => {
+      console.error("[MCP Error]", error);
+    };
+
+    process.on("SIGINT", async () => {
+      await this.cleanup();
+      process.exit(0);
+    });
+  }
+
+  async cleanup() {
+    // Logout from tenant
+    if (this.isAuthenticated && this.sessionToken) {
+      try {
+        await this.logout();
+      } catch (error) {
+        console.error(`Failed to logout:`, error.message);
+      }
+    }
+  }
+
+  /**
+   * Normalize tenant URL by removing trailing slashes
+   */
+  normalizeTenantUrl(url) {
+    return url.replace(/\/+$/, "");
+  }
+
+  /**
+   * Ensure we have a valid session, authenticate if needed
+   */
+  async ensureAuthenticated() {
+    // If bearer token is provided, use it directly
+    if (this.bearerToken) {
+      this.sessionToken = this.bearerToken;
+      this.isAuthenticated = true;
+      return;
+    }
+
+    // Check if credentials are configured
+    if (!this.tenantUrl || !this.username || !this.password) {
+      throw new Error(
+        "Vunet tenant not configured. Please set VUNET_TENANT_URL, VUNET_USERNAME, and VUNET_PASSWORD environment variables."
+      );
+    }
+
+    // Check if we have a valid session
+    if (this.isAuthenticated && this.sessionToken) {
+      if (this.sessionExpiry && Date.now() < this.sessionExpiry) {
+        return; // Session is still valid
+      }
+    }
+
+    // Need to authenticate
+    await this.login();
+  }
+
+  /**
+   * Login to Vunet tenant
+   */
+  async login() {
+    const url = `${this.normalizeTenantUrl(this.tenantUrl)}/vuSmartMaps/api/1/bu/${this.buId}/auth/users/login/`;
+
+    try {
+      const response = await axios.post(
+        url,
+        {
+          username: this.username,
+          password: this.password,
+        },
+        {
+          httpsAgent: this.httpsAgent,
+        }
+      );
+
+      if (response.data && response.data.access_token) {
+        this.sessionToken = response.data.access_token;
+        
+        // Set expiry to 1 hour from now (adjust based on actual token expiry if available)
+        this.sessionExpiry = Date.now() + 60 * 60 * 1000;
+        this.isAuthenticated = true;
+
+        console.error(`[Vunet MCP] Successfully authenticated to ${this.tenantUrl}`);
+      } else {
+        throw new Error("No access token in response");
+      }
+    } catch (error) {
+      this.isAuthenticated = false;
+      throw new Error(
+        `Failed to authenticate to Vunet: ${error.response?.data?.message || error.message}`
+      );
+    }
+  }
+
+  /**
+   * Logout from Vunet tenant
+   */
+  async logout() {
+    if (!this.sessionToken) return;
+
+    const url = `${this.normalizeTenantUrl(this.tenantUrl)}/vuSmartMaps/api/1/bu/${this.buId}/auth/users/logout/`;
+
+    try {
+      await axios.post(
+        url,
+        {},
+        {
+          headers: {
+            Authorization: `Bearer ${this.sessionToken}`,
+          },
+          httpsAgent: this.httpsAgent,
+        }
+      );
+
+      console.error(`[Vunet MCP] Successfully logged out from ${this.tenantUrl}`);
+    } catch (error) {
+      console.error(`[Vunet MCP] Logout failed: ${error.message}`);
+    } finally {
+      this.sessionToken = null;
+      this.sessionExpiry = null;
+      this.isAuthenticated = false;
+    }
+  }
+
+  /**
+   * Build query parameters for metric query
+   */
+  buildQueryParams(args) {
+    const params = {};
+
+    // Time parameters
+    if (args.relative_time) {
+      params.relative_time = args.relative_time;
+    } else if (args.start_time && args.end_time) {
+      params.start_time = args.start_time;
+      params.end_time = args.end_time;
+    }
+
+    // Filters (dynamic)
+    if (args.filters && typeof args.filters === "object") {
+      Object.assign(params, args.filters);
+    }
+
+    // Field inclusion/exclusion
+    if (args.include) params.include = args.include;
+    if (args.exclude) params.exclude = args.exclude;
+
+    // Other options
+    if (args.thresholds !== undefined) params.thresholds = args.thresholds;
+    if (args.formatting) params.formatting = args.formatting;
+    if (args.add_on_time_intervals) params.add_on_time_intervals = args.add_on_time_intervals;
+    if (args.add_on_data_models) params.add_on_data_models = args.add_on_data_models;
+    if (args.time_shift) params.time_shift = args.time_shift;
+
+    return params;
+  }
+
+  /**
+   * Query a metric/data model
+   */
+  async queryMetric(metricName, queryParams) {
+    await this.ensureAuthenticated();
+
+    const url = `${this.normalizeTenantUrl(this.tenantUrl)}/api/metrics/${metricName}/`;
+
+    try {
+      const response = await axios.get(url, {
+        params: queryParams,
+        headers: {
+          Authorization: `Bearer ${this.sessionToken}`,
+        },
+        httpsAgent: this.httpsAgent,
+      });
+
+      return response.data;
+    } catch (error) {
+      if (error.response?.status === 401) {
+        // Session expired, try to re-authenticate
+        this.isAuthenticated = false;
+        await this.ensureAuthenticated();
+        
+        // Retry the request
+        const retryResponse = await axios.get(url, {
+          params: queryParams,
+          headers: {
+            Authorization: `Bearer ${this.sessionToken}`,
+          },
+          httpsAgent: this.httpsAgent,
+        });
+        return retryResponse.data;
+      }
+
+      throw new Error(
+        `Failed to query metric '${metricName}': ${error.response?.data?.message || error.message}`
+      );
+    }
+  }
+
+  setupHandlers() {
+    // List available tools
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+      tools: [
+        {
+          name: "vunet_query_metric",
+          description: "Query a Vunet data model/metric with flexible time ranges and filters. Automatically uses the configured tenant.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              metric_name: {
+                type: "string",
+                description: "Name of the data model/metric to query (e.g., 'datamodel-metric-api')",
+              },
+              relative_time: {
+                type: "string",
+                description: "Relative time (e.g., '15m', '1h', '1d', '1w', '1M', '1y')",
+              },
+              start_time: {
+                type: "string",
+                description: "Start time (epoch timestamp or 'now', 'now-1h', etc.). Use with end_time instead of relative_time.",
+              },
+              end_time: {
+                type: "string",
+                description: "End time (epoch timestamp or 'now', 'now-1h', etc.). Use with start_time instead of relative_time.",
+              },
+              filters: {
+                type: "object",
+                description: "Dynamic filters as key-value pairs (e.g., {\"ip\": \"192.168.0.1\", \"status\": \"active\"})",
+              },
+              include: {
+                type: "string",
+                description: "Comma-separated fields to include in response",
+              },
+              exclude: {
+                type: "string",
+                description: "Comma-separated fields to exclude from response",
+              },
+              thresholds: {
+                type: "boolean",
+                description: "Include threshold data in response (default: false)",
+              },
+              formatting: {
+                type: "string",
+                description: "Response format. Use 'lama' for LAMA format (Log Analytics)",
+                enum: ["lama"],
+              },
+              add_on_time_intervals: {
+                type: "array",
+                description: "Additional time intervals for comparison (e.g., ['1h_ago', '1d_ago'])",
+                items: { type: "string" },
+              },
+              add_on_data_models: {
+                type: "string",
+                description: "Comma-separated additional data models to join",
+              },
+              time_shift: {
+                type: "string",
+                description: "Time shift for comparison (e.g., '1h', '1d', '1w')",
+              },
+            },
+            required: ["metric_name"],
+          },
+        },
+        {
+          name: "vunet_get_status",
+          description: "Get the current connection status and tenant information",
+          inputSchema: {
+            type: "object",
+            properties: {},
+          },
+        },
+        {
+          name: "vunet_list_data_models",
+          description: "List common Vunet data models organized by category (APM, Infrastructure, Database, Network, etc.)",
+          inputSchema: {
+            type: "object",
+            properties: {
+              category: {
+                type: "string",
+                description: "Filter by category: 'apm', 'infrastructure', 'database', 'network', 'business', 'all' (default: 'all')",
+                enum: ["all", "apm", "infrastructure", "database", "network", "business", "logs", "security"],
+              },
+            },
+          },
+        },
+      ],
+    }));
+
+    // Handle tool calls
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const { name, arguments: args } = request.params;
+
+      try {
+        switch (name) {
+          case "vunet_query_metric":
+            return await this.handleQueryMetric(args);
+          
+          case "vunet_get_status":
+            return await this.handleGetStatus();
+
+          case "vunet_list_data_models":
+            return await this.handleListDataModels(args);
+
+          default:
+            throw new Error(`Unknown tool: ${name}`);
+        }
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${error.message}`,
+            },
+          ],
+          isError: true,
+        };
+      }
+    });
+  }
+
+  async handleQueryMetric(args) {
+    const { metric_name, ...queryArgs } = args;
+
+    if (!metric_name) {
+      throw new Error("metric_name is required");
+    }
+
+    const queryParams = this.buildQueryParams(queryArgs);
+    const result = await this.queryMetric(metric_name, queryParams);
+
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(result, null, 2),
+        },
+      ],
+    };
+  }
+
+  async handleGetStatus() {
+    const status = {
+      configured: !!(this.tenantUrl && this.username && this.password),
+      tenant_url: this.tenantUrl || "Not configured",
+      bu_id: this.buId,
+      authenticated: this.isAuthenticated,
+      session_valid: this.isAuthenticated && this.sessionExpiry && Date.now() < this.sessionExpiry,
+      session_expires_in: this.sessionExpiry ? Math.max(0, this.sessionExpiry - Date.now()) / 1000 : 0,
+    };
+
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(status, null, 2),
+        },
+      ],
+    };
+  }
+
+  async handleListDataModels(args = {}) {
+    const category = args.category || "all";
+
+    const dataModels = {
+      apm: [
+        "Trace Map Data",
+        "Traces Transaction Volume",
+        "Application Response Time",
+        "Error Rate",
+        "Service Dependencies",
+        "Endpoint Performance",
+        "JVM Metrics",
+        "Thread Pool Metrics",
+        "GC Metrics",
+        "Hibernate Query Performance",
+        "Cache Hit Ratio"
+      ],
+      infrastructure: [
+        "Kubernetes Pod Metrics",
+        "Kubernetes Node Metrics",
+        "Kubernetes Deployment Metrics",
+        "Kubernetes Service Metrics",
+        "Kubernetes Namespace Metrics",
+        "Container Metrics",
+        "Kubernetes Events",
+        "CPU Usage",
+        "Memory Usage",
+        "Disk I/O",
+        "Network I/O",
+        "File System Usage",
+        "System Load",
+        "Apache Metrics",
+        "Nginx Metrics",
+        "Tomcat Metrics",
+        "IIS Metrics"
+      ],
+      database: [
+        "MySQL Performance",
+        "MySQL Slow Queries",
+        "PostgreSQL Metrics",
+        "Oracle Metrics",
+        "SQL Server Metrics",
+        "Database Connection Pool",
+        "MongoDB Metrics",
+        "Redis Metrics",
+        "Cassandra Metrics",
+        "Elasticsearch Metrics"
+      ],
+      network: [
+        "Network Latency",
+        "Packet Loss",
+        "Bandwidth Usage",
+        "TCP Connections",
+        "DNS Query Performance",
+        "SSL Certificate Expiry"
+      ],
+      business: [
+        "VuBank Metrics",
+        "Transaction Success Rate",
+        "User Sessions",
+        "Revenue Metrics",
+        "Conversion Rate",
+        "Customer Activity"
+      ],
+      logs: [
+        "Application Logs",
+        "Error Logs",
+        "Security Logs",
+        "Audit Logs",
+        "Access Logs"
+      ],
+      security: [
+        "Security Events",
+        "Failed Login Attempts",
+        "Privileged Access",
+        "Vulnerability Scan Results",
+        "Compliance Metrics"
+      ]
+    };
+
+    let result;
+    if (category === "all") {
+      result = {
+        message: "Common Vunet data models by category (80+ total)",
+        note: "Actual available models depend on your tenant configuration",
+        categories: dataModels,
+        total_listed: Object.values(dataModels).flat().length,
+        usage: "Use these names with the vunet_query_metric tool"
+      };
+    } else if (dataModels[category]) {
+      result = {
+        category: category.toUpperCase(),
+        models: dataModels[category],
+        count: dataModels[category].length,
+        usage: "Use these names with the vunet_query_metric tool"
+      };
+    } else {
+      result = {
+        error: `Unknown category: ${category}`,
+        available_categories: Object.keys(dataModels),
+        usage: "Specify 'all' or one of the available categories"
+      };
+    }
+
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(result, null, 2),
+        },
+      ],
+    };
+  }
+
+  async run() {
+    console.error("Vunet MCP Server starting...");
+    
+    // Log configuration status
+    if (this.tenantUrl && this.username && this.password) {
+      console.error(`[Vunet MCP] Configured for tenant: ${this.tenantUrl}`);
+      console.error(`[Vunet MCP] Business Unit ID: ${this.buId}`);
+      console.error(`[Vunet MCP] SSL Verification: ${this.httpsAgent.options.rejectUnauthorized ? 'Enabled' : 'Disabled'}`);
+    } else {
+      console.error(`[Vunet MCP] WARNING: Tenant not configured!`);
+      console.error(`[Vunet MCP] Set VUNET_TENANT_URL, VUNET_USERNAME, and VUNET_PASSWORD environment variables`);
+    }
+
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+    console.error("Vunet MCP Server running on stdio");
+  }
+}
+
+// Start the server
+const server = new VunetMCPServer();
+server.run().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});

package/mcp-config.example.json

@@ -0,0 +1,42 @@
+{
+  "mcpServers": {
+    "vunet-production": {
+      "command": "npx",
+      "args": [
+        "@vunet/mcp-server"
+      ],
+      "env": {
+        "VUNET_TENANT_URL": "https://your-production-tenant.com",
+        "VUNET_USERNAME": "admin",
+        "VUNET_PASSWORD": "your-secure-password",
+        "VUNET_BU_ID": "1",
+        "VUNET_VERIFY_SSL": "true"
+      }
+    },
+    "vunet-staging": {
+      "command": "npx",
+      "args": [
+        "@vunet/mcp-server"
+      ],
+      "env": {
+        "VUNET_TENANT_URL": "https://staging-tenant.com",
+        "VUNET_BEARER_TOKEN": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
+        "VUNET_BU_ID": "1",
+        "VUNET_VERIFY_SSL": "true"
+      }
+    },
+    "vunet-dev": {
+      "command": "node",
+      "args": [
+        "C:\\path\\to\\vunet-mcp-server\\index.js"
+      ],
+      "env": {
+        "VUNET_TENANT_URL": "https://20.198.26.207",
+        "VUNET_USERNAME": "vunetadmin",
+        "VUNET_PASSWORD": "Qwerty@123",
+        "VUNET_BU_ID": "1",
+        "VUNET_VERIFY_SSL": "false"
+      }
+    }
+  }
+}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@mithung/vunet-mcp-server",
+  "version": "2.0.0",
+  "description": "Model Context Protocol (MCP) Server for Vunet vuSmartMaps - Multi-tenant observability platform integration",
+  "main": "index.js",
+  "type": "module",
+  "bin": {
+    "vunet-mcp": "./index.js"
+  },
+  "scripts": {
+    "start": "node index.js",
+    "dev": "node --watch index.js",
+    "test": "echo \"No tests specified yet\" && exit 0"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "vunet",
+    "vusmartmaps",
+    "metric-api",
+    "monitoring",
+    "observability",
+    "analytics",
+    "apm",
+    "traces",
+    "metrics",
+    "logs",
+    "dynatrace-alternative"
+  ],
+  "author": {
+    "name": "Vunet Systems",
+    "url": "https://vunetsystems.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mithung/vunet-mcp-server.git"
+  },
+  "bugs": {
+    "url": "https://github.com/mithung/vunet-mcp-server/issues"
+  },
+  "homepage": "https://github.com/mithung/vunet-mcp-server#readme",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    "axios": "^1.7.2"
+  },
+  "devDependencies": {},
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "index.js",
+    "README.md",
+    "SETUP.md",
+    "QUICKSTART.md",
+    "DATA_MODELS.md",
+    "CHANGELOG.md",
+    "LICENSE",
+    "config.example.json",
+    "mcp-config.example.json"
+  ]
+}