@influxdata/influxdb3-mcp-server 1.3.0

package/build/services/cloud-token-management.service.js

@@ -0,0 +1,179 @@
+/**
+ * InfluxDB Cloud-Dedicated/Clustered Token Management Service
+ *
+ * Handles database token operations for InfluxDB Cloud-Dedicated and Clustered clusters
+ * Uses REST API endpoints instead of SQL queries
+ */
+import { InfluxProductType } from "../helpers/enums/influx-product-types.enum.js";
+export class CloudTokenManagementService {
+    baseService;
+    constructor(baseService) {
+        this.baseService = baseService;
+    }
+    /**
+     * List all database tokens for the cloud-dedicated/clustered cluster
+     * GET /api/v0/accounts/{accountId}/clusters/{clusterId}/tokens
+     */
+    async listTokens() {
+        this.baseService.validateOperationSupport("list_cloud_tokens", [
+            InfluxProductType.CloudDedicated,
+            InfluxProductType.Clustered,
+        ]);
+        this.baseService.validateManagementCapabilities();
+        try {
+            const httpClient = this.baseService.getInfluxHttpClient(true);
+            const config = this.baseService.getConfig();
+            const endpoint = `/api/v0/accounts/${config.influx.account_id}/clusters/${config.influx.cluster_id}/tokens`;
+            const response = await httpClient.get(endpoint);
+            return Array.isArray(response) ? response : [];
+        }
+        catch (error) {
+            this.handleTokenError(error, "list tokens");
+        }
+    }
+    /**
+     * Get a specific token by ID
+     * GET /api/v0/accounts/{accountId}/clusters/{clusterId}/tokens/{tokenId}
+     */
+    async getToken(tokenId) {
+        this.baseService.validateOperationSupport("get_cloud_token", [
+            InfluxProductType.CloudDedicated,
+            InfluxProductType.Clustered,
+        ]);
+        this.baseService.validateManagementCapabilities();
+        try {
+            const httpClient = this.baseService.getInfluxHttpClient(true);
+            const config = this.baseService.getConfig();
+            const endpoint = `/api/v0/accounts/${config.influx.account_id}/clusters/${config.influx.cluster_id}/tokens/${tokenId}`;
+            const response = await httpClient.get(endpoint);
+            return response;
+        }
+        catch (error) {
+            this.handleTokenError(error, `get token '${tokenId}'`);
+        }
+    }
+    /**
+     * Create a new database token
+     * POST /api/v0/accounts/{accountId}/clusters/{clusterId}/tokens
+     */
+    async createToken(request) {
+        this.baseService.validateOperationSupport("create_cloud_token", [
+            InfluxProductType.CloudDedicated,
+            InfluxProductType.Clustered,
+        ]);
+        this.baseService.validateManagementCapabilities();
+        try {
+            const httpClient = this.baseService.getInfluxHttpClient(true);
+            const config = this.baseService.getConfig();
+            const endpoint = `/api/v0/accounts/${config.influx.account_id}/clusters/${config.influx.cluster_id}/tokens`;
+            const response = await httpClient.post(endpoint, request);
+            return response;
+        }
+        catch (error) {
+            this.handleTokenError(error, `create token '${request.description}'`);
+        }
+    }
+    /**
+     * Update an existing token
+     * PATCH /api/v0/accounts/{accountId}/clusters/{clusterId}/tokens/{tokenId}
+     */
+    async updateToken(tokenId, request) {
+        this.baseService.validateOperationSupport("update_cloud_token", [
+            InfluxProductType.CloudDedicated,
+            InfluxProductType.Clustered,
+        ]);
+        this.baseService.validateManagementCapabilities();
+        try {
+            const httpClient = this.baseService.getInfluxHttpClient(true);
+            const config = this.baseService.getConfig();
+            const endpoint = `/api/v0/accounts/${config.influx.account_id}/clusters/${config.influx.cluster_id}/tokens/${tokenId}`;
+            const response = await httpClient.patch(endpoint, request);
+            return response;
+        }
+        catch (error) {
+            this.handleTokenError(error, `update token '${tokenId}'`);
+        }
+    }
+    /**
+     * Delete a token
+     * DELETE /api/v0/accounts/{accountId}/clusters/{clusterId}/tokens/{tokenId}
+     */
+    async deleteToken(tokenId) {
+        this.baseService.validateOperationSupport("delete_cloud_token", [
+            InfluxProductType.CloudDedicated,
+            InfluxProductType.Clustered,
+        ]);
+        this.baseService.validateManagementCapabilities();
+        try {
+            const httpClient = this.baseService.getInfluxHttpClient(true);
+            const config = this.baseService.getConfig();
+            const endpoint = `/api/v0/accounts/${config.influx.account_id}/clusters/${config.influx.cluster_id}/tokens/${tokenId}`;
+            await httpClient.delete(endpoint);
+            return true;
+        }
+        catch (error) {
+            this.handleTokenError(error, `delete token '${tokenId}'`);
+        }
+    }
+    /**
+     * Helper method to create permissions for specific databases and actions
+     */
+    createPermissions(databases, actions) {
+        const permissions = [];
+        for (const database of databases) {
+            for (const action of actions) {
+                permissions.push({
+                    action,
+                    resource: database,
+                });
+            }
+        }
+        return permissions;
+    }
+    /**
+     * Common error handling for token operations
+     */
+    handleTokenError(error, operation) {
+        const status = error.response?.status;
+        const originalMessage = error.response?.data?.message ||
+            error.response?.data?.error ||
+            (typeof error.response?.data === "string" ? error.response.data : null) ||
+            error.response?.statusText;
+        const statusText = error.response?.statusText || "";
+        const formatError = (userMessage) => {
+            const parts = [`HTTP ${status}`, userMessage];
+            if (originalMessage && originalMessage !== statusText) {
+                parts.push(`Server message: ${originalMessage}`);
+            }
+            return parts.join(" - ");
+        };
+        switch (status) {
+            case 400:
+                throw new Error(formatError("Bad Request: Invalid request parameters or malformed request"));
+            case 401:
+                throw new Error(formatError("Unauthorized: Check your InfluxDB management token permissions"));
+            case 403:
+                throw new Error(formatError("Forbidden: Management token does not have sufficient permissions"));
+            case 404:
+                throw new Error(formatError("Not Found: Token does not exist or endpoint not available"));
+            case 409:
+                throw new Error(formatError("Conflict: Token already exists or operation conflicts with current state"));
+            case 500:
+                throw new Error(formatError("Internal Server Error: InfluxDB server encountered an error"));
+            default:
+                if (error.code === "ECONNREFUSED") {
+                    throw new Error("Connection refused: Check if InfluxDB Cloud console is accessible");
+                }
+                else if (error.code === "ENOTFOUND") {
+                    throw new Error("Host not found: Check your InfluxDB Cloud console URL");
+                }
+                else if (error.response?.data) {
+                    const message = originalMessage || JSON.stringify(error.response.data);
+                    throw new Error(`HTTP ${status} - InfluxDB Cloud API error: ${message}`);
+                }
+                else {
+                    throw new Error(`Failed to ${operation}: ${error.message}`);
+                }
+        }
+    }
+}

package/build/services/context-file.service.js

@@ -0,0 +1,97 @@
+/**
+ * Context File Service
+ *
+ * Searches for and loads custom context files to enhance the MCP server
+ * with user-specific database descriptions or documentation.
+ */
+import { readFileSync, existsSync, readdirSync } from "fs";
+import { join, extname, basename } from "path";
+export class ContextFileService {
+    workingDirectory;
+    constructor(workingDirectory = process.cwd()) {
+        this.workingDirectory = workingDirectory;
+    }
+    /**
+     * Search for and load context file
+     * Priority:
+     * 1. /context/ folder (any file)
+     * 2. Files with "context" in name with .json, .txt, .md extensions
+     */
+    async loadContextFile() {
+        try {
+            const contextFolderPath = join(this.workingDirectory, "context");
+            const contextFolderFile = this.searchInContextFolder(contextFolderPath);
+            if (contextFolderFile) {
+                return contextFolderFile;
+            }
+            const contextNamedFile = this.searchForContextNamedFiles();
+            return contextNamedFile;
+        }
+        catch (error) {
+            console.error("Error loading context file:", error.message);
+            return null;
+        }
+    }
+    /**
+     * Search for files in /context/ folder
+     */
+    searchInContextFolder(contextFolderPath) {
+        if (!existsSync(contextFolderPath)) {
+            return null;
+        }
+        try {
+            const files = readdirSync(contextFolderPath);
+            const validExtensions = [".json", ".txt", ".md"];
+            for (const file of files) {
+                const filePath = join(contextFolderPath, file);
+                const ext = extname(file).toLowerCase();
+                if (validExtensions.includes(ext)) {
+                    const content = readFileSync(filePath, "utf-8");
+                    return {
+                        path: filePath,
+                        name: basename(file, ext),
+                        extension: ext.substring(1),
+                        content,
+                        exists: true,
+                    };
+                }
+            }
+        }
+        catch (error) {
+            console.error("Error reading context folder:", error.message);
+        }
+        return null;
+    }
+    /**
+     * Search for files with "context" in name
+     */
+    searchForContextNamedFiles() {
+        try {
+            const files = readdirSync(this.workingDirectory);
+            const validExtensions = [".json", ".txt", ".md"];
+            const contextFiles = files.filter((file) => {
+                const ext = extname(file).toLowerCase();
+                const nameWithoutExt = basename(file, ext).toLowerCase();
+                return (validExtensions.includes(ext) && nameWithoutExt.includes("context"));
+            });
+            if (contextFiles.length === 0) {
+                return null;
+            }
+            const file = contextFiles[0];
+            const filePath = join(this.workingDirectory, file);
+            const ext = extname(file).toLowerCase();
+            const content = readFileSync(filePath, "utf-8");
+            return {
+                path: filePath,
+                name: basename(file, ext),
+                extension: ext.substring(1),
+                content,
+                exists: true,
+            };
+        }
+        catch (error) {
+            console.error("Error searching for context files:", error.message);
+            return null;
+        }
+    }
+}