@berthojoris/mcp-mysql-server 1.4.15 → 1.6.0

package/dist/index.js

@@ -12,6 +12,13 @@ const ddlTools_1 = require("./tools/ddlTools");
 const transactionTools_1 = require("./tools/transactionTools");
 const storedProcedureTools_1 = require("./tools/storedProcedureTools");
 const dataExportTools_1 = require("./tools/dataExportTools");
+const viewTools_1 = require("./tools/viewTools");
+const triggerTools_1 = require("./tools/triggerTools");
+const functionTools_1 = require("./tools/functionTools");
+const indexTools_1 = require("./tools/indexTools");
+const constraintTools_1 = require("./tools/constraintTools");
+const maintenanceTools_1 = require("./tools/maintenanceTools");
+const processTools_1 = require("./tools/processTools");
 const securityLayer_1 = __importDefault(require("./security/securityLayer"));
 const connection_1 = __importDefault(require("./db/connection"));
 const featureConfig_1 = require("./config/featureConfig");
@@ -31,95 +38,102 @@ class MySQLMCP {
         this.transactionTools = new transactionTools_1.TransactionTools();
         this.storedProcedureTools = new storedProcedureTools_1.StoredProcedureTools(this.security);
         this.dataExportTools = new dataExportTools_1.DataExportTools(this.security);
+        this.viewTools = new viewTools_1.ViewTools(this.security);
+        this.triggerTools = new triggerTools_1.TriggerTools(this.security);
+        this.functionTools = new functionTools_1.FunctionTools(this.security);
+        this.indexTools = new indexTools_1.IndexTools(this.security);
+        this.constraintTools = new constraintTools_1.ConstraintTools(this.security);
+        this.maintenanceTools = new maintenanceTools_1.MaintenanceTools(this.security);
+        this.processTools = new processTools_1.ProcessTools(this.security);
     }
     // Helper method to check if tool is enabled
     checkToolEnabled(toolName) {
         if (!this.featureConfig.isToolEnabled(toolName)) {
             return {
                 enabled: false,
-                error: this.featureConfig.getPermissionError(toolName)
+                error: this.featureConfig.getPermissionError(toolName),
             };
         }
         return { enabled: true };
     }
     // Database Tools
     async listDatabases() {
-        const check = this.checkToolEnabled('listDatabases');
+        const check = this.checkToolEnabled("listDatabases");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.dbTools.listDatabases();
     }
     async listTables(params) {
-        const check = this.checkToolEnabled('listTables');
+        const check = this.checkToolEnabled("listTables");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.dbTools.listTables(params);
     }
     async readTableSchema(params) {
-        const check = this.checkToolEnabled('readTableSchema');
+        const check = this.checkToolEnabled("readTableSchema");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.dbTools.readTableSchema(params);
     }
     // CRUD Tools
     async createRecord(params) {
-        const check = this.checkToolEnabled('createRecord');
+        const check = this.checkToolEnabled("createRecord");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.crudTools.createRecord(params);
     }
     async readRecords(params) {
-        const check = this.checkToolEnabled('readRecords');
+        const check = this.checkToolEnabled("readRecords");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.crudTools.readRecords(params);
     }
     async updateRecord(params) {
-        const check = this.checkToolEnabled('updateRecord');
+        const check = this.checkToolEnabled("updateRecord");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.crudTools.updateRecord(params);
     }
     async deleteRecord(params) {
-        const check = this.checkToolEnabled('deleteRecord');
+        const check = this.checkToolEnabled("deleteRecord");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.crudTools.deleteRecord(params);
     }
     // Query Tools
     async runQuery(params) {
-        const check = this.checkToolEnabled('runQuery');
+        const check = this.checkToolEnabled("runQuery");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         // Additional security check
         if (!this.security.isReadOnlyQuery(params.query)) {
             return {
-                status: 'error',
-                error: 'Only SELECT queries are allowed with runQuery. Use executeSql for other operations.'
+                status: "error",
+                error: "Only SELECT queries are allowed with runQuery. Use executeSql for other operations.",
             };
         }
         return await this.queryTools.runQuery(params);
     }
     async executeSql(params) {
-        const check = this.checkToolEnabled('executeSql');
+        const check = this.checkToolEnabled("executeSql");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         // Additional security check - block DDL unless DDL permission is enabled
         if (this.security.hasDangerousOperations(params.query)) {
             // Check if DDL permission is enabled
-            if (!this.featureConfig.isCategoryEnabled('ddl')) {
+            if (!this.featureConfig.isCategoryEnabled("ddl")) {
                 return {
-                    status: 'error',
-                    error: 'DDL operations (DROP, TRUNCATE, ALTER, CREATE) require the "ddl" permission. Use executeDdl tool or add "ddl" to permissions.'
+                    status: "error",
+                    error: 'DDL operations (DROP, TRUNCATE, ALTER, CREATE) require the "ddl" permission. Use executeDdl tool or add "ddl" to permissions.',
                 };
             }
         }
@@ -127,178 +141,178 @@ class MySQLMCP {
     }
     // DDL Tools
     async createTable(params) {
-        const check = this.checkToolEnabled('createTable');
+        const check = this.checkToolEnabled("createTable");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.ddlTools.createTable(params);
     }
     async alterTable(params) {
-        const check = this.checkToolEnabled('alterTable');
+        const check = this.checkToolEnabled("alterTable");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.ddlTools.alterTable(params);
     }
     async dropTable(params) {
-        const check = this.checkToolEnabled('dropTable');
+        const check = this.checkToolEnabled("dropTable");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.ddlTools.dropTable(params);
     }
     async executeDdl(params) {
-        const check = this.checkToolEnabled('executeDdl');
+        const check = this.checkToolEnabled("executeDdl");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.ddlTools.executeDdl(params);
     }
     // Utility Tools
     async describeConnection() {
-        const check = this.checkToolEnabled('describeConnection');
+        const check = this.checkToolEnabled("describeConnection");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.utilityTools.describeConnection();
     }
     async testConnection() {
-        const check = this.checkToolEnabled('testConnection');
+        const check = this.checkToolEnabled("testConnection");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.utilityTools.testConnection();
     }
     async getTableRelationships(params) {
-        const check = this.checkToolEnabled('getTableRelationships');
+        const check = this.checkToolEnabled("getTableRelationships");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.utilityTools.getTableRelationships(params);
     }
     // Transaction Tools
     async beginTransaction(params) {
-        const check = this.checkToolEnabled('beginTransaction');
+        const check = this.checkToolEnabled("beginTransaction");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.transactionTools.beginTransaction(params);
     }
     async commitTransaction(params) {
-        const check = this.checkToolEnabled('commitTransaction');
+        const check = this.checkToolEnabled("commitTransaction");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.transactionTools.commitTransaction(params);
     }
     async rollbackTransaction(params) {
-        const check = this.checkToolEnabled('rollbackTransaction');
+        const check = this.checkToolEnabled("rollbackTransaction");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.transactionTools.rollbackTransaction(params);
     }
     async getTransactionStatus() {
-        const check = this.checkToolEnabled('getTransactionStatus');
+        const check = this.checkToolEnabled("getTransactionStatus");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.transactionTools.getTransactionStatus();
     }
     async executeInTransaction(params) {
-        const check = this.checkToolEnabled('executeSql'); // Use executeSql permission for transaction queries
+        const check = this.checkToolEnabled("executeSql"); // Use executeSql permission for transaction queries
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.transactionTools.executeInTransaction(params);
     }
     // Stored Procedure Tools
     async listStoredProcedures(params) {
-        const check = this.checkToolEnabled('listStoredProcedures');
+        const check = this.checkToolEnabled("listStoredProcedures");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.storedProcedureTools.listStoredProcedures(params);
     }
     async getStoredProcedureInfo(params) {
-        const check = this.checkToolEnabled('getStoredProcedureInfo');
+        const check = this.checkToolEnabled("getStoredProcedureInfo");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.storedProcedureTools.getStoredProcedureInfo(params);
     }
     async executeStoredProcedure(params) {
-        const check = this.checkToolEnabled('executeStoredProcedure');
+        const check = this.checkToolEnabled("executeStoredProcedure");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.storedProcedureTools.executeStoredProcedure(params);
     }
     async createStoredProcedure(params) {
-        const check = this.checkToolEnabled('createStoredProcedure');
+        const check = this.checkToolEnabled("createStoredProcedure");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.storedProcedureTools.createStoredProcedure(params);
     }
     async dropStoredProcedure(params) {
-        const check = this.checkToolEnabled('dropStoredProcedure');
+        const check = this.checkToolEnabled("dropStoredProcedure");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.storedProcedureTools.dropStoredProcedure(params);
     }
     async showCreateProcedure(params) {
-        const check = this.checkToolEnabled('showCreateProcedure');
+        const check = this.checkToolEnabled("showCreateProcedure");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.storedProcedureTools.showCreateProcedure(params);
     }
     // Data Export Tools
     async exportTableToCSV(params) {
-        const check = this.checkToolEnabled('exportTableToCSV');
+        const check = this.checkToolEnabled("exportTableToCSV");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.dataExportTools.exportTableToCSV(params);
     }
     async exportQueryToCSV(params) {
-        const check = this.checkToolEnabled('exportQueryToCSV');
+        const check = this.checkToolEnabled("exportQueryToCSV");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.dataExportTools.exportQueryToCSV(params);
     }
     // Get feature configuration status
     getFeatureStatus() {
         return {
-            status: 'success',
+            status: "success",
             data: {
                 enabledCategories: this.featureConfig.getEnabledCategories(),
-                categoryStatus: this.featureConfig.getCategoryStatus()
-            }
+                categoryStatus: this.featureConfig.getCategoryStatus(),
+            },
         };
     }
     /**
      * Bulk insert multiple records into the specified table
      */
     async bulkInsert(params) {
-        this.checkToolEnabled('bulk_insert');
+        this.checkToolEnabled("bulk_insert");
         return this.crudTools.bulkInsert(params);
     }
     /**
      * Bulk update multiple records with different conditions and data
      */
     async bulkUpdate(params) {
-        this.checkToolEnabled('bulk_update');
+        this.checkToolEnabled("bulk_update");
         return this.crudTools.bulkUpdate(params);
     }
     /**
      * Bulk delete records based on multiple condition sets
      */
     async bulkDelete(params) {
-        this.checkToolEnabled('bulk_delete');
+        this.checkToolEnabled("bulk_delete");
         return this.crudTools.bulkDelete(params);
     }
     // Close database connection
@@ -306,6 +320,394 @@ class MySQLMCP {
         const db = connection_1.default.getInstance();
         await db.closePool();
     }
+    // ==========================================
+    // Cache Management Methods
+    // ==========================================
+    /**
+     * Get cache statistics
+     */
+    getCacheStats() {
+        const db = connection_1.default.getInstance();
+        return {
+            status: "success",
+            data: db.getCacheStats(),
+        };
+    }
+    /**
+     * Get cache configuration
+     */
+    getCacheConfig() {
+        const db = connection_1.default.getInstance();
+        return {
+            status: "success",
+            data: db.getCacheConfig(),
+        };
+    }
+    /**
+     * Configure cache settings
+     */
+    configureCacheSettings(params) {
+        const db = connection_1.default.getInstance();
+        db.setCacheConfig(params);
+        return {
+            status: "success",
+            data: {
+                message: "Cache configuration updated successfully",
+                config: db.getCacheConfig(),
+            },
+        };
+    }
+    /**
+     * Clear the query cache
+     */
+    clearCache() {
+        const db = connection_1.default.getInstance();
+        const clearedCount = db.clearCache();
+        return {
+            status: "success",
+            data: {
+                message: `Cache cleared successfully`,
+                entriesCleared: clearedCount,
+            },
+        };
+    }
+    /**
+     * Invalidate cache for a specific table
+     */
+    invalidateCacheForTable(params) {
+        const db = connection_1.default.getInstance();
+        const invalidatedCount = db.invalidateCacheForTable(params.table_name);
+        return {
+            status: "success",
+            data: {
+                message: `Cache invalidated for table '${params.table_name}'`,
+                entriesInvalidated: invalidatedCount,
+            },
+        };
+    }
+    // ==========================================
+    // Query Optimization Methods
+    // ==========================================
+    /**
+     * Analyze a query and get optimization suggestions
+     */
+    analyzeQuery(params) {
+        const analysis = this.queryTools.analyzeQuery(params.query);
+        return {
+            status: "success",
+            data: analysis,
+        };
+    }
+    /**
+     * Get suggested optimizer hints for a specific optimization goal
+     */
+    getOptimizationHints(params) {
+        const hints = this.queryTools.getSuggestedHints(params.goal);
+        return {
+            status: "success",
+            data: {
+                goal: params.goal,
+                hints,
+            },
+        };
+    }
+    // ==========================================
+    // View Tools
+    // ==========================================
+    async listViews(params) {
+        const check = this.checkToolEnabled("listViews");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.viewTools.listViews(params);
+    }
+    async getViewInfo(params) {
+        const check = this.checkToolEnabled("getViewInfo");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.viewTools.getViewInfo(params);
+    }
+    async createView(params) {
+        const check = this.checkToolEnabled("createView");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.viewTools.createView(params);
+    }
+    async alterView(params) {
+        const check = this.checkToolEnabled("alterView");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.viewTools.alterView(params);
+    }
+    async dropView(params) {
+        const check = this.checkToolEnabled("dropView");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.viewTools.dropView(params);
+    }
+    async showCreateView(params) {
+        const check = this.checkToolEnabled("showCreateView");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.viewTools.showCreateView(params);
+    }
+    // ==========================================
+    // Trigger Tools
+    // ==========================================
+    async listTriggers(params) {
+        const check = this.checkToolEnabled("listTriggers");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.triggerTools.listTriggers(params);
+    }
+    async getTriggerInfo(params) {
+        const check = this.checkToolEnabled("getTriggerInfo");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.triggerTools.getTriggerInfo(params);
+    }
+    async createTrigger(params) {
+        const check = this.checkToolEnabled("createTrigger");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.triggerTools.createTrigger(params);
+    }
+    async dropTrigger(params) {
+        const check = this.checkToolEnabled("dropTrigger");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.triggerTools.dropTrigger(params);
+    }
+    async showCreateTrigger(params) {
+        const check = this.checkToolEnabled("showCreateTrigger");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.triggerTools.showCreateTrigger(params);
+    }
+    // ==========================================
+    // Function Tools
+    // ==========================================
+    async listFunctions(params) {
+        const check = this.checkToolEnabled("listFunctions");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.functionTools.listFunctions(params);
+    }
+    async getFunctionInfo(params) {
+        const check = this.checkToolEnabled("getFunctionInfo");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.functionTools.getFunctionInfo(params);
+    }
+    async createFunction(params) {
+        const check = this.checkToolEnabled("createFunction");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.functionTools.createFunction(params);
+    }
+    async dropFunction(params) {
+        const check = this.checkToolEnabled("dropFunction");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.functionTools.dropFunction(params);
+    }
+    async showCreateFunction(params) {
+        const check = this.checkToolEnabled("showCreateFunction");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.functionTools.showCreateFunction(params);
+    }
+    async executeFunction(params) {
+        const check = this.checkToolEnabled("executeFunction");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.functionTools.executeFunction(params);
+    }
+    // ==========================================
+    // Index Tools
+    // ==========================================
+    async listIndexes(params) {
+        const check = this.checkToolEnabled("listIndexes");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.indexTools.listIndexes(params);
+    }
+    async getIndexInfo(params) {
+        const check = this.checkToolEnabled("getIndexInfo");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.indexTools.getIndexInfo(params);
+    }
+    async createIndex(params) {
+        const check = this.checkToolEnabled("createIndex");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.indexTools.createIndex(params);
+    }
+    async dropIndex(params) {
+        const check = this.checkToolEnabled("dropIndex");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.indexTools.dropIndex(params);
+    }
+    async analyzeIndex(params) {
+        const check = this.checkToolEnabled("analyzeIndex");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.indexTools.analyzeIndex(params);
+    }
+    // ==========================================
+    // Constraint Tools
+    // ==========================================
+    async listForeignKeys(params) {
+        const check = this.checkToolEnabled("listForeignKeys");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.constraintTools.listForeignKeys(params);
+    }
+    async listConstraints(params) {
+        const check = this.checkToolEnabled("listConstraints");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.constraintTools.listConstraints(params);
+    }
+    async addForeignKey(params) {
+        const check = this.checkToolEnabled("addForeignKey");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.constraintTools.addForeignKey(params);
+    }
+    async dropForeignKey(params) {
+        const check = this.checkToolEnabled("dropForeignKey");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.constraintTools.dropForeignKey(params);
+    }
+    async addUniqueConstraint(params) {
+        const check = this.checkToolEnabled("addUniqueConstraint");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.constraintTools.addUniqueConstraint(params);
+    }
+    async dropConstraint(params) {
+        const check = this.checkToolEnabled("dropConstraint");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.constraintTools.dropConstraint(params);
+    }
+    async addCheckConstraint(params) {
+        const check = this.checkToolEnabled("addCheckConstraint");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.constraintTools.addCheckConstraint(params);
+    }
+    // ==========================================
+    // Table Maintenance Tools
+    // ==========================================
+    async analyzeTable(params) {
+        const check = this.checkToolEnabled("analyzeTable");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.maintenanceTools.analyzeTable(params);
+    }
+    async optimizeTable(params) {
+        const check = this.checkToolEnabled("optimizeTable");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.maintenanceTools.optimizeTable(params);
+    }
+    async checkTable(params) {
+        const check = this.checkToolEnabled("checkTable");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.maintenanceTools.checkTable(params);
+    }
+    async repairTable(params) {
+        const check = this.checkToolEnabled("repairTable");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.maintenanceTools.repairTable(params);
+    }
+    async truncateTable(params) {
+        const check = this.checkToolEnabled("truncateTable");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.maintenanceTools.truncateTable(params);
+    }
+    async getTableStatus(params) {
+        const check = this.checkToolEnabled("getTableStatus");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.maintenanceTools.getTableStatus(params);
+    }
+    async flushTable(params) {
+        const check = this.checkToolEnabled("flushTable");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.maintenanceTools.flushTable(params);
+    }
+    async getTableSize(params) {
+        const check = this.checkToolEnabled("getTableSize");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.maintenanceTools.getTableSize(params);
+    }
+    // ==========================================
+    // Process Management Tools
+    // ==========================================
+    async showProcessList(params) {
+        const check = this.checkToolEnabled("showProcessList");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.processTools.showProcessList(params);
+    }
+    async killProcess(params) {
+        const check = this.checkToolEnabled("killProcess");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.processTools.killProcess(params);
+    }
+    async showStatus(params) {
+        const check = this.checkToolEnabled("showStatus");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.processTools.showStatus(params);
+    }
+    async showVariables(params) {
+        const check = this.checkToolEnabled("showVariables");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.processTools.showVariables(params);
+    }
+    async explainQuery(params) {
+        const check = this.checkToolEnabled("explainQuery");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.processTools.explainQuery(params);
+    }
+    async showEngineStatus(params) {
+        const check = this.checkToolEnabled("showEngineStatus");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.processTools.showEngineStatus(params);
+    }
+    async getServerInfo() {
+        const check = this.checkToolEnabled("getServerInfo");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.processTools.getServerInfo();
+    }
+    async showBinaryLogs() {
+        const check = this.checkToolEnabled("showBinaryLogs");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.processTools.showBinaryLogs();
+    }
+    async showReplicationStatus(params) {
+        const check = this.checkToolEnabled("showReplicationStatus");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.processTools.showReplicationStatus(params);
+    }
 }
 exports.MySQLMCP = MySQLMCP;
 exports.default = MySQLMCP;