@influxdata/influxdb3-mcp-server 1.3.0

package/build/tools/categories/cloud-token.tools.js

@@ -0,0 +1,321 @@
+/**
+ * Cloud Token Management Tools (Cloud-Dedicated/Clustered)
+ */
+import { z } from "zod";
+export function createCloudTokenTools(influxService) {
+    return [
+        {
+            name: "cloud_list_database_tokens",
+            description: "List all database tokens for InfluxDB Cloud-Dedicated/Clustered cluster. Returns token information including permissions and creation dates.",
+            inputSchema: {
+                type: "object",
+                properties: {},
+                additionalProperties: false,
+            },
+            zodSchema: z.object({}),
+            handler: async () => {
+                try {
+                    const cloudTokenService = influxService.getCloudTokenManagementService();
+                    const tokens = await cloudTokenService.listTokens();
+                    const tokenCount = tokens.length;
+                    const tokenList = tokens
+                        .map((token) => `• ${token.description} (ID: ${token.id})\n  Permissions: ${token.permissions.length > 0 ? token.permissions.map((p) => `${p.action}:${p.resource}`).join(", ") : "No access"}\n  Created: ${token.createdAt}`)
+                        .join("\n");
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Found ${tokenCount} database token${tokenCount !== 1 ? "s" : ""} in Cloud-Dedicated/Clustered cluster:\n\n${tokenList || "None"}\n\nFull details:\n${JSON.stringify(tokens, null, 2)}`,
+                            },
+                        ],
+                    };
+                }
+                catch (error) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Error: ${error.message}`,
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+            },
+        },
+        {
+            name: "cloud_get_database_token",
+            description: "Get details of a specific database token by ID for InfluxDB Cloud-Dedicated/Clustered cluster.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    token_id: {
+                        type: "string",
+                        description: "The ID of the token to retrieve",
+                    },
+                },
+                required: ["token_id"],
+                additionalProperties: false,
+            },
+            zodSchema: z.object({
+                token_id: z.string().describe("The ID of the token to retrieve"),
+            }),
+            handler: async (args) => {
+                try {
+                    const cloudTokenService = influxService.getCloudTokenManagementService();
+                    const token = await cloudTokenService.getToken(args.token_id);
+                    const permissionsList = token.permissions.length > 0
+                        ? token.permissions
+                            .map((p) => `${p.action}:${p.resource}`)
+                            .join(", ")
+                        : "No access";
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Database Token Details:\n\nDescription: ${token.description}\nID: ${token.id}\nPermissions: ${permissionsList}\nCreated: ${token.createdAt}\nAccount ID: ${token.accountId}\nCluster ID: ${token.clusterId}\n\nFull details:\n${JSON.stringify(token, null, 2)}`,
+                            },
+                        ],
+                    };
+                }
+                catch (error) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Error: ${error.message}`,
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+            },
+        },
+        {
+            name: "cloud_create_database_token",
+            description: 'Create a new database token for InfluxDB Cloud-Dedicated/Clustered cluster. Specify exact permissions per database or create a no-access token.\n\nPermissions format: [{"database": "db_name", "action": "read|write"}, ...]\nExamples:\n• No access: omit permissions field or use []\n• Read-only on \'analytics\': [{"database": "analytics", "action": "read"}]\n• Mixed permissions: [{"database": "logs", "action": "read"}, {"database": "metrics", "action": "write"}]\n• Full access: [{"database": "*", "action": "read"}, {"database": "*", "action": "write"}]',
+            inputSchema: {
+                type: "object",
+                properties: {
+                    description: {
+                        type: "string",
+                        description: "Description/name for the token",
+                    },
+                    permissions: {
+                        type: "array",
+                        items: {
+                            type: "object",
+                            properties: {
+                                database: {
+                                    type: "string",
+                                    description: "Database name or '*' for all databases",
+                                },
+                                action: {
+                                    type: "string",
+                                    enum: ["read", "write"],
+                                    description: "Permission level for this database",
+                                },
+                            },
+                            required: ["database", "action"],
+                            additionalProperties: false,
+                        },
+                        description: "Array of permission objects. Each object specifies database and action. Leave empty array [] for no-access token.",
+                    },
+                },
+                required: ["description"],
+                additionalProperties: false,
+            },
+            zodSchema: z.object({
+                description: z.string().describe("Description/name for the token"),
+                permissions: z
+                    .array(z.object({
+                    database: z
+                        .string()
+                        .describe("Database name or '*' for all databases"),
+                    action: z
+                        .enum(["read", "write"])
+                        .describe("Permission level for this database"),
+                }))
+                    .optional()
+                    .describe("Array of permission objects. Omit or use empty array for no-access token"),
+            }),
+            handler: async (args) => {
+                try {
+                    const cloudTokenService = influxService.getCloudTokenManagementService();
+                    const permissions = (args.permissions || []).map((p) => ({
+                        action: p.action,
+                        resource: p.database,
+                    }));
+                    const result = await cloudTokenService.createToken({
+                        description: args.description,
+                        permissions,
+                    });
+                    const permissionsList = result.permissions.length > 0
+                        ? result.permissions
+                            .map((p) => `${p.action}:${p.resource}`)
+                            .join(", ")
+                        : "No access";
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Database token created successfully!\n\nDescription: ${result.description}\nToken ID: ${result.id}\nPermissions: ${permissionsList}\nAccess Token: ${result.accessToken}\n\n⚠️ Store this access token securely - it won't be shown again!`,
+                            },
+                        ],
+                    };
+                }
+                catch (error) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Error: ${error.message}`,
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+            },
+        },
+        {
+            name: "cloud_update_database_token",
+            description: 'Update an existing database token for InfluxDB Cloud-Dedicated/Clustered cluster. Can update description and/or permissions with precise control.\n\nPermissions format: [{"database": "db_name", "action": "read|write"}, ...]\nNote: Permissions completely replace existing ones - include all desired permissions.\nExamples:\n• No access: use []\n• Read-only on \'analytics\': [{"database": "analytics", "action": "read"}]\n• Mixed permissions: [{"database": "logs", "action": "read"}, {"database": "metrics", "action": "write"}]\n• Full access: [{"database": "*", "action": "read"}, {"database": "*", "action": "write"}]',
+            inputSchema: {
+                type: "object",
+                properties: {
+                    token_id: {
+                        type: "string",
+                        description: "The ID of the token to update",
+                    },
+                    description: {
+                        type: "string",
+                        description: "New description for the token (optional)",
+                    },
+                    permissions: {
+                        type: "array",
+                        items: {
+                            type: "object",
+                            properties: {
+                                database: {
+                                    type: "string",
+                                    description: "Database name or '*' for all databases",
+                                },
+                                action: {
+                                    type: "string",
+                                    enum: ["read", "write"],
+                                    description: "Permission level for this database",
+                                },
+                            },
+                            required: ["database", "action"],
+                            additionalProperties: false,
+                        },
+                        description: "Array of permission objects. Each object specifies database and action. Use empty array [] for no-access token.",
+                    },
+                },
+                required: ["token_id"],
+                additionalProperties: false,
+            },
+            zodSchema: z.object({
+                token_id: z.string().describe("The ID of the token to update"),
+                description: z
+                    .string()
+                    .optional()
+                    .describe("New description for the token"),
+                permissions: z
+                    .array(z.object({
+                    database: z
+                        .string()
+                        .describe("Database name or '*' for all databases"),
+                    action: z
+                        .enum(["read", "write"])
+                        .describe("Permission level for this database"),
+                }))
+                    .optional()
+                    .describe("Array of permission objects. Use empty array for no-access token"),
+            }),
+            handler: async (args) => {
+                try {
+                    const cloudTokenService = influxService.getCloudTokenManagementService();
+                    const updateRequest = {};
+                    if (args.description !== undefined) {
+                        updateRequest.description = args.description;
+                    }
+                    if (args.permissions !== undefined) {
+                        updateRequest.permissions = args.permissions.map((p) => ({
+                            action: p.action,
+                            resource: p.database,
+                        }));
+                    }
+                    const result = await cloudTokenService.updateToken(args.token_id, updateRequest);
+                    const permissionsList = result.permissions.length > 0
+                        ? result.permissions
+                            .map((p) => `${p.action}:${p.resource}`)
+                            .join(", ")
+                        : "No access";
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Database token updated successfully!\n\nDescription: ${result.description}\nToken ID: ${result.id}\nPermissions: ${permissionsList}\nCreated: ${result.createdAt}`,
+                            },
+                        ],
+                    };
+                }
+                catch (error) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Error: ${error.message}`,
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+            },
+        },
+        {
+            name: "cloud_delete_database_token",
+            description: "Delete a database token from InfluxDB Cloud-Dedicated/Clustered cluster. This action cannot be undone.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    token_id: {
+                        type: "string",
+                        description: "The ID of the token to delete",
+                    },
+                },
+                required: ["token_id"],
+                additionalProperties: false,
+            },
+            zodSchema: z.object({
+                token_id: z.string().describe("The ID of the token to delete"),
+            }),
+            handler: async (args) => {
+                try {
+                    const cloudTokenService = influxService.getCloudTokenManagementService();
+                    await cloudTokenService.deleteToken(args.token_id);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Database token '${args.token_id}' deleted successfully.`,
+                            },
+                        ],
+                    };
+                }
+                catch (error) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Error: ${error.message}`,
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+            },
+        },
+    ];
+}

package/build/tools/categories/database.tools.js

@@ -0,0 +1,299 @@
+/**
+ * Database Management Tools
+ */
+import { z } from "zod";
+export function createDatabaseTools(influxService) {
+    return [
+        {
+            name: "create_database",
+            description: "Create a new database in InfluxDB. Database names must follow InfluxDB naming rules: alphanumeric characters, dashes (-), underscores (_), and forward slashes (/) are allowed. Must start with a letter or number. Maximum 64 characters. For Cloud Dedicated/Clustered: maxTables, maxColumnsPerTable, retentionPeriod. For Cloud Serverless: description, retentionPeriod.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    name: {
+                        type: "string",
+                        description: "Name of the database to create (alphanumeric, -, _, / allowed; max 64 chars; must start with letter/number)",
+                        pattern: "^[a-zA-Z0-9][a-zA-Z0-9\\-_/]*$",
+                        maxLength: 64,
+                    },
+                    description: {
+                        type: "string",
+                        description: "Description for the bucket/database (Cloud Serverless only)",
+                    },
+                    maxTables: {
+                        type: "number",
+                        description: "Maximum number of tables (Cloud Dedicated/Clustered only, default: 500)",
+                        minimum: 1,
+                    },
+                    maxColumnsPerTable: {
+                        type: "number",
+                        description: "Maximum columns per table (Cloud Dedicated/Clustered only, default: 200)",
+                        minimum: 1,
+                    },
+                    retentionPeriod: {
+                        type: "number",
+                        description: "Retention period in nanoseconds (Cloud Dedicated/Clustered: default 0 = no expiration, Cloud Serverless: default 30 days)",
+                        minimum: 0,
+                    },
+                },
+                required: ["name"],
+                additionalProperties: false,
+            },
+            zodSchema: z.object({
+                name: z
+                    .string()
+                    .min(1, "Database name cannot be empty")
+                    .max(64, "Database name cannot exceed 64 characters")
+                    .regex(/^[a-zA-Z0-9]/, "Database name must start with a letter or number")
+                    .regex(/^[a-zA-Z0-9\-_/]+$/, "Database name can only contain alphanumeric characters, dashes (-), underscores (_), and forward slashes (/)")
+                    .describe("Name of the database to create"),
+                description: z
+                    .string()
+                    .optional()
+                    .describe("Description for the bucket/database (Cloud Serverless only)"),
+                maxTables: z
+                    .number()
+                    .min(1)
+                    .optional()
+                    .describe("Maximum number of tables (Cloud Dedicated/Clustered only)"),
+                maxColumnsPerTable: z
+                    .number()
+                    .min(1)
+                    .optional()
+                    .describe("Maximum columns per table (Cloud Dedicated/Clustered only)"),
+                retentionPeriod: z
+                    .number()
+                    .min(0)
+                    .optional()
+                    .describe("Retention period in nanoseconds"),
+            }),
+            handler: async (args) => {
+                try {
+                    const config = args.maxTables !== undefined ||
+                        args.maxColumnsPerTable !== undefined ||
+                        args.retentionPeriod !== undefined ||
+                        args.description !== undefined
+                        ? {
+                            name: args.name,
+                            ...(args.maxTables !== undefined && {
+                                maxTables: args.maxTables,
+                            }),
+                            ...(args.maxColumnsPerTable !== undefined && {
+                                maxColumnsPerTable: args.maxColumnsPerTable,
+                            }),
+                            ...(args.description !== undefined && {
+                                description: args.description,
+                            }),
+                            ...(args.retentionPeriod !== undefined && {
+                                retentionPeriod: args.retentionPeriod,
+                            }),
+                        }
+                        : undefined;
+                    await influxService.database.createDatabase(args.name, config);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Database '${args.name}' created successfully`,
+                            },
+                        ],
+                    };
+                }
+                catch (error) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Error: ${error.message}`,
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+            },
+        },
+        {
+            name: "update_database",
+            description: "Update database configuration for InfluxDB Cloud Dedicated/Clustered clusters and Cloud Serverless buckets. For Cloud Dedicated/Clustered: modify maxTables, maxColumnsPerTable, and retentionPeriod. For Cloud Serverless: modify bucket name, description, and retentionPeriod. Not available for Core/Enterprise installations.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    name: {
+                        type: "string",
+                        description: "Name of the database/bucket to update",
+                    },
+                    newName: {
+                        type: "string",
+                        description: "New name for the database/bucket (Cloud Serverless only)",
+                    },
+                    description: {
+                        type: "string",
+                        description: "Description for the bucket (Cloud Serverless only)",
+                    },
+                    maxTables: {
+                        type: "number",
+                        description: "Maximum number of tables (Cloud Dedicated/Clustered only)",
+                        minimum: 1,
+                    },
+                    maxColumnsPerTable: {
+                        type: "number",
+                        description: "Maximum columns per table (Cloud Dedicated/Clustered only)",
+                        minimum: 1,
+                    },
+                    retentionPeriod: {
+                        type: "number",
+                        description: "Retention period in nanoseconds (Cloud Dedicated/Clustered and Cloud Serverless)",
+                        minimum: 0,
+                    },
+                },
+                required: ["name"],
+                additionalProperties: false,
+            },
+            zodSchema: z.object({
+                name: z.string().describe("Name of the database/bucket to update"),
+                newName: z
+                    .string()
+                    .optional()
+                    .describe("New name for the database/bucket (Cloud Serverless only)"),
+                description: z
+                    .string()
+                    .optional()
+                    .describe("Description for the bucket (Cloud Serverless only)"),
+                maxTables: z
+                    .number()
+                    .min(1)
+                    .optional()
+                    .describe("Maximum number of tables (Cloud Dedicated/Clustered only)"),
+                maxColumnsPerTable: z
+                    .number()
+                    .min(1)
+                    .optional()
+                    .describe("Maximum columns per table (Cloud Dedicated/Clustered only)"),
+                retentionPeriod: z
+                    .number()
+                    .min(0)
+                    .optional()
+                    .describe("Retention period in nanoseconds"),
+            }),
+            handler: async (args) => {
+                try {
+                    const config = {};
+                    if (args.maxTables !== undefined)
+                        config.maxTables = args.maxTables;
+                    if (args.maxColumnsPerTable !== undefined)
+                        config.maxColumnsPerTable = args.maxColumnsPerTable;
+                    if (args.newName !== undefined)
+                        config.name = args.newName;
+                    if (args.description !== undefined)
+                        config.description = args.description;
+                    if (args.retentionPeriod !== undefined)
+                        config.retentionPeriod = args.retentionPeriod;
+                    if (Object.keys(config).length === 0) {
+                        throw new Error("At least one configuration parameter must be provided");
+                    }
+                    await influxService.database.updateDatabase(args.name, config);
+                    const updatedFields = Object.keys(config)
+                        .map((key) => `${key}: ${config[key]}`)
+                        .join(", ");
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Database '${args.name}' updated successfully with: ${updatedFields}`,
+                            },
+                        ],
+                    };
+                }
+                catch (error) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Error: ${error.message}`,
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+            },
+        },
+        {
+            name: "delete_database",
+            description: "Delete a database from InfluxDB. Use the exact database name as returned by the list_databases tool.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    name: {
+                        type: "string",
+                        description: "Name of the database to delete (use exact name from database list)",
+                    },
+                },
+                required: ["name"],
+                additionalProperties: false,
+            },
+            zodSchema: z.object({
+                name: z.string().describe("Name of the database to delete"),
+            }),
+            handler: async (args) => {
+                try {
+                    await influxService.database.deleteDatabase(args.name);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Database '${args.name}' deleted successfully`,
+                            },
+                        ],
+                    };
+                }
+                catch (error) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Error: ${error.message}`,
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+            },
+        },
+        {
+            name: "list_databases",
+            description: "List all databases in the InfluxDB instance (all versions). Returns database names, count, and status information.",
+            inputSchema: {
+                type: "object",
+                properties: {},
+                additionalProperties: false,
+            },
+            zodSchema: z.object({}),
+            handler: async () => {
+                try {
+                    const databases = await influxService.database.listDatabases();
+                    const databaseList = databases.map((db) => db.name).join(", ");
+                    const count = databases.length;
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Found ${count} database${count !== 1 ? "s" : ""} in InfluxDB instance:\n${databaseList || "None"}\n\nDatabase details:\n${JSON.stringify(databases, null, 2)}`,
+                            },
+                        ],
+                    };
+                }
+                catch (error) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Error listing databases: ${error.message}`,
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+            },
+        },
+    ];
+}