@berthojoris/mcp-mysql-server 1.5.0 → 1.6.0

package/dist/tools/maintenanceTools.js

@@ -0,0 +1,371 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MaintenanceTools = void 0;
+const connection_1 = __importDefault(require("../db/connection"));
+const config_1 = require("../config/config");
+class MaintenanceTools {
+    constructor(security) {
+        this.db = connection_1.default.getInstance();
+        this.security = security;
+    }
+    /**
+     * Validate database access - ensures only the connected database can be accessed
+     */
+    validateDatabaseAccess(requestedDatabase) {
+        const connectedDatabase = config_1.dbConfig.database;
+        if (!connectedDatabase) {
+            return {
+                valid: false,
+                database: '',
+                error: 'No database specified in connection string. Cannot access any database.'
+            };
+        }
+        if (!requestedDatabase) {
+            return {
+                valid: true,
+                database: connectedDatabase
+            };
+        }
+        if (requestedDatabase !== connectedDatabase) {
+            return {
+                valid: false,
+                database: '',
+                error: `Access denied. You can only access the connected database '${connectedDatabase}'. Requested database '${requestedDatabase}' is not allowed.`
+            };
+        }
+        return {
+            valid: true,
+            database: connectedDatabase
+        };
+    }
+    /**
+     * Analyze table to update index statistics
+     */
+    async analyzeTable(params) {
+        try {
+            const dbValidation = this.validateDatabaseAccess(params?.database);
+            if (!dbValidation.valid) {
+                return { status: 'error', error: dbValidation.error };
+            }
+            const { table_name } = params;
+            const database = dbValidation.database;
+            // Validate table name
+            if (!this.security.validateIdentifier(table_name).valid) {
+                return { status: 'error', error: 'Invalid table name' };
+            }
+            const query = `ANALYZE TABLE \`${database}\`.\`${table_name}\``;
+            const results = await this.db.query(query);
+            return {
+                status: 'success',
+                data: results[0],
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+        catch (error) {
+            return {
+                status: 'error',
+                error: error.message,
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+    }
+    /**
+     * Optimize table to reclaim unused space and defragment
+     */
+    async optimizeTable(params) {
+        try {
+            const dbValidation = this.validateDatabaseAccess(params?.database);
+            if (!dbValidation.valid) {
+                return { status: 'error', error: dbValidation.error };
+            }
+            const { table_name } = params;
+            const database = dbValidation.database;
+            // Validate table name
+            if (!this.security.validateIdentifier(table_name).valid) {
+                return { status: 'error', error: 'Invalid table name' };
+            }
+            const query = `OPTIMIZE TABLE \`${database}\`.\`${table_name}\``;
+            const results = await this.db.query(query);
+            return {
+                status: 'success',
+                data: results[0],
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+        catch (error) {
+            return {
+                status: 'error',
+                error: error.message,
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+    }
+    /**
+     * Check table for errors
+     */
+    async checkTable(params) {
+        try {
+            const dbValidation = this.validateDatabaseAccess(params?.database);
+            if (!dbValidation.valid) {
+                return { status: 'error', error: dbValidation.error };
+            }
+            const { table_name, check_type } = params;
+            const database = dbValidation.database;
+            // Validate table name
+            if (!this.security.validateIdentifier(table_name).valid) {
+                return { status: 'error', error: 'Invalid table name' };
+            }
+            let query = `CHECK TABLE \`${database}\`.\`${table_name}\``;
+            if (check_type) {
+                query += ` ${check_type}`;
+            }
+            const results = await this.db.query(query);
+            return {
+                status: 'success',
+                data: results[0],
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+        catch (error) {
+            return {
+                status: 'error',
+                error: error.message,
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+    }
+    /**
+     * Repair table (MyISAM, ARCHIVE, CSV only)
+     */
+    async repairTable(params) {
+        try {
+            const dbValidation = this.validateDatabaseAccess(params?.database);
+            if (!dbValidation.valid) {
+                return { status: 'error', error: dbValidation.error };
+            }
+            const { table_name, quick = false, extended = false, use_frm = false } = params;
+            const database = dbValidation.database;
+            // Validate table name
+            if (!this.security.validateIdentifier(table_name).valid) {
+                return { status: 'error', error: 'Invalid table name' };
+            }
+            let query = `REPAIR TABLE \`${database}\`.\`${table_name}\``;
+            const options = [];
+            if (quick)
+                options.push('QUICK');
+            if (extended)
+                options.push('EXTENDED');
+            if (use_frm)
+                options.push('USE_FRM');
+            if (options.length > 0) {
+                query += ` ${options.join(' ')}`;
+            }
+            const results = await this.db.query(query);
+            return {
+                status: 'success',
+                data: results[0],
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+        catch (error) {
+            return {
+                status: 'error',
+                error: error.message,
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+    }
+    /**
+     * Truncate table (remove all rows quickly)
+     */
+    async truncateTable(params) {
+        try {
+            const dbValidation = this.validateDatabaseAccess(params?.database);
+            if (!dbValidation.valid) {
+                return { status: 'error', error: dbValidation.error };
+            }
+            const { table_name } = params;
+            const database = dbValidation.database;
+            // Validate table name
+            if (!this.security.validateIdentifier(table_name).valid) {
+                return { status: 'error', error: 'Invalid table name' };
+            }
+            const query = `TRUNCATE TABLE \`${database}\`.\`${table_name}\``;
+            await this.db.query(query);
+            return {
+                status: 'success',
+                message: `Table '${table_name}' truncated successfully`,
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+        catch (error) {
+            return {
+                status: 'error',
+                error: error.message,
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+    }
+    /**
+     * Get table status and statistics
+     */
+    async getTableStatus(params) {
+        try {
+            const dbValidation = this.validateDatabaseAccess(params?.database);
+            if (!dbValidation.valid) {
+                return { status: 'error', error: dbValidation.error };
+            }
+            const { table_name } = params;
+            const database = dbValidation.database;
+            let query = `SHOW TABLE STATUS FROM \`${database}\``;
+            if (table_name) {
+                if (!this.security.validateIdentifier(table_name).valid) {
+                    return { status: 'error', error: 'Invalid table name' };
+                }
+                query += ` LIKE '${table_name}'`;
+            }
+            const results = await this.db.query(query);
+            // Format results for better readability
+            const formattedResults = results.map(row => ({
+                table_name: row.Name,
+                engine: row.Engine,
+                version: row.Version,
+                row_format: row.Row_format,
+                rows: row.Rows,
+                avg_row_length: row.Avg_row_length,
+                data_length: row.Data_length,
+                max_data_length: row.Max_data_length,
+                index_length: row.Index_length,
+                data_free: row.Data_free,
+                auto_increment: row.Auto_increment,
+                create_time: row.Create_time,
+                update_time: row.Update_time,
+                check_time: row.Check_time,
+                collation: row.Collation,
+                checksum: row.Checksum,
+                create_options: row.Create_options,
+                comment: row.Comment
+            }));
+            return {
+                status: 'success',
+                data: table_name ? formattedResults[0] : formattedResults,
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+        catch (error) {
+            return {
+                status: 'error',
+                error: error.message,
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+    }
+    /**
+     * Flush table (close and reopen)
+     */
+    async flushTable(params) {
+        try {
+            const dbValidation = this.validateDatabaseAccess(params?.database);
+            if (!dbValidation.valid) {
+                return { status: 'error', error: dbValidation.error };
+            }
+            const { table_name, with_read_lock = false } = params;
+            const database = dbValidation.database;
+            let query;
+            if (table_name) {
+                if (!this.security.validateIdentifier(table_name).valid) {
+                    return { status: 'error', error: 'Invalid table name' };
+                }
+                query = `FLUSH TABLES \`${database}\`.\`${table_name}\``;
+                if (with_read_lock) {
+                    query += ' WITH READ LOCK';
+                }
+            }
+            else {
+                query = with_read_lock ? 'FLUSH TABLES WITH READ LOCK' : 'FLUSH TABLES';
+            }
+            await this.db.query(query);
+            return {
+                status: 'success',
+                message: table_name
+                    ? `Table '${table_name}' flushed successfully${with_read_lock ? ' with read lock' : ''}`
+                    : `All tables flushed successfully${with_read_lock ? ' with read lock' : ''}`,
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+        catch (error) {
+            return {
+                status: 'error',
+                error: error.message,
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+    }
+    /**
+     * Get table size information
+     */
+    async getTableSize(params) {
+        try {
+            const dbValidation = this.validateDatabaseAccess(params?.database);
+            if (!dbValidation.valid) {
+                return { status: 'error', error: dbValidation.error };
+            }
+            const { table_name } = params;
+            const database = dbValidation.database;
+            let query = `
+        SELECT
+          TABLE_NAME as table_name,
+          TABLE_ROWS as row_count,
+          DATA_LENGTH as data_size_bytes,
+          INDEX_LENGTH as index_size_bytes,
+          (DATA_LENGTH + INDEX_LENGTH) as total_size_bytes,
+          ROUND((DATA_LENGTH + INDEX_LENGTH) / 1024 / 1024, 2) as total_size_mb,
+          DATA_FREE as free_space_bytes,
+          ENGINE as engine,
+          TABLE_COLLATION as collation
+        FROM INFORMATION_SCHEMA.TABLES
+        WHERE TABLE_SCHEMA = ?
+      `;
+            const queryParams = [database];
+            if (table_name) {
+                if (!this.security.validateIdentifier(table_name).valid) {
+                    return { status: 'error', error: 'Invalid table name' };
+                }
+                query += ` AND TABLE_NAME = ?`;
+                queryParams.push(table_name);
+            }
+            query += ` ORDER BY (DATA_LENGTH + INDEX_LENGTH) DESC`;
+            const results = await this.db.query(query, queryParams);
+            // Calculate totals if getting all tables
+            let totalStats = null;
+            if (!table_name && results.length > 0) {
+                totalStats = {
+                    total_tables: results.length,
+                    total_rows: results.reduce((sum, r) => sum + (r.row_count || 0), 0),
+                    total_data_size_bytes: results.reduce((sum, r) => sum + (r.data_size_bytes || 0), 0),
+                    total_index_size_bytes: results.reduce((sum, r) => sum + (r.index_size_bytes || 0), 0),
+                    total_size_mb: results.reduce((sum, r) => sum + (parseFloat(r.total_size_mb) || 0), 0).toFixed(2)
+                };
+            }
+            return {
+                status: 'success',
+                data: {
+                    tables: table_name ? results[0] : results,
+                    ...(totalStats && { summary: totalStats })
+                },
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+        catch (error) {
+            return {
+                status: 'error',
+                error: error.message,
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+    }
+}
+exports.MaintenanceTools = MaintenanceTools;

package/dist/tools/processTools.d.ts

@@ -0,0 +1,106 @@
+import { SecurityLayer } from '../security/securityLayer';
+export declare class ProcessTools {
+    private db;
+    private security;
+    constructor(security: SecurityLayer);
+    /**
+     * Show all running processes/connections
+     */
+    showProcessList(params?: {
+        full?: boolean;
+    }): Promise<{
+        status: string;
+        data?: any[];
+        error?: string;
+        queryLog?: string;
+    }>;
+    /**
+     * Kill a specific process/connection
+     */
+    killProcess(params: {
+        process_id: number;
+        type?: 'CONNECTION' | 'QUERY';
+    }): Promise<{
+        status: string;
+        message?: string;
+        error?: string;
+        queryLog?: string;
+    }>;
+    /**
+     * Show server status variables
+     */
+    showStatus(params?: {
+        like?: string;
+        global?: boolean;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+    /**
+     * Show server variables
+     */
+    showVariables(params?: {
+        like?: string;
+        global?: boolean;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+    /**
+     * Explain a query (show execution plan)
+     */
+    explainQuery(params: {
+        query: string;
+        format?: 'TRADITIONAL' | 'JSON' | 'TREE';
+        analyze?: boolean;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+    /**
+     * Show engine status (InnoDB, etc.)
+     */
+    showEngineStatus(params?: {
+        engine?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+    /**
+     * Get server information
+     */
+    getServerInfo(): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+    /**
+     * Show binary logs
+     */
+    showBinaryLogs(): Promise<{
+        status: string;
+        data?: any[];
+        error?: string;
+        queryLog?: string;
+    }>;
+    /**
+     * Show master/replica status
+     */
+    showReplicationStatus(params?: {
+        type?: 'MASTER' | 'REPLICA' | 'SLAVE';
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+}