@berthojoris/mcp-mysql-server 1.5.0 → 1.6.1

package/dist/tools/processTools.js

@@ -0,0 +1,305 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcessTools = void 0;
+const connection_1 = __importDefault(require("../db/connection"));
+class ProcessTools {
+    constructor(security) {
+        this.db = connection_1.default.getInstance();
+        this.security = security;
+    }
+    /**
+     * Show all running processes/connections
+     */
+    async showProcessList(params) {
+        try {
+            const query = params?.full ? 'SHOW FULL PROCESSLIST' : 'SHOW PROCESSLIST';
+            const results = await this.db.query(query);
+            // Format results for better readability
+            const formattedResults = results.map(row => ({
+                id: row.Id,
+                user: row.User,
+                host: row.Host,
+                database: row.db,
+                command: row.Command,
+                time: row.Time,
+                state: row.State,
+                info: row.Info,
+                progress: row.Progress
+            }));
+            return {
+                status: 'success',
+                data: formattedResults,
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+        catch (error) {
+            return {
+                status: 'error',
+                error: error.message,
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+    }
+    /**
+     * Kill a specific process/connection
+     */
+    async killProcess(params) {
+        try {
+            const { process_id, type = 'CONNECTION' } = params;
+            // Validate process_id is a positive integer
+            if (!Number.isInteger(process_id) || process_id <= 0) {
+                return { status: 'error', error: 'Process ID must be a positive integer' };
+            }
+            const query = type === 'QUERY'
+                ? `KILL QUERY ${process_id}`
+                : `KILL ${process_id}`;
+            await this.db.query(query);
+            return {
+                status: 'success',
+                message: type === 'QUERY'
+                    ? `Query for process ${process_id} killed successfully`
+                    : `Process ${process_id} killed successfully`,
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+        catch (error) {
+            return {
+                status: 'error',
+                error: error.message,
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+    }
+    /**
+     * Show server status variables
+     */
+    async showStatus(params) {
+        try {
+            let query = params?.global ? 'SHOW GLOBAL STATUS' : 'SHOW STATUS';
+            if (params?.like) {
+                // Validate the LIKE pattern (basic check)
+                if (params.like.includes(';') || params.like.includes('--')) {
+                    return { status: 'error', error: 'Invalid pattern' };
+                }
+                query += ` LIKE '${params.like}'`;
+            }
+            const results = await this.db.query(query);
+            // Convert to object for easier access
+            const statusObj = {};
+            for (const row of results) {
+                statusObj[row.Variable_name] = row.Value;
+            }
+            return {
+                status: 'success',
+                data: params?.like ? statusObj : {
+                    variables: statusObj,
+                    count: results.length
+                },
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+        catch (error) {
+            return {
+                status: 'error',
+                error: error.message,
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+    }
+    /**
+     * Show server variables
+     */
+    async showVariables(params) {
+        try {
+            let query = params?.global ? 'SHOW GLOBAL VARIABLES' : 'SHOW VARIABLES';
+            if (params?.like) {
+                // Validate the LIKE pattern (basic check)
+                if (params.like.includes(';') || params.like.includes('--')) {
+                    return { status: 'error', error: 'Invalid pattern' };
+                }
+                query += ` LIKE '${params.like}'`;
+            }
+            const results = await this.db.query(query);
+            // Convert to object for easier access
+            const varsObj = {};
+            for (const row of results) {
+                varsObj[row.Variable_name] = row.Value;
+            }
+            return {
+                status: 'success',
+                data: params?.like ? varsObj : {
+                    variables: varsObj,
+                    count: results.length
+                },
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+        catch (error) {
+            return {
+                status: 'error',
+                error: error.message,
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+    }
+    /**
+     * Explain a query (show execution plan)
+     */
+    async explainQuery(params) {
+        try {
+            const { query, format = 'TRADITIONAL', analyze = false } = params;
+            // Only allow SELECT, UPDATE, DELETE, INSERT queries to be explained
+            const normalizedQuery = query.trim().toUpperCase();
+            if (!normalizedQuery.startsWith('SELECT') &&
+                !normalizedQuery.startsWith('UPDATE') &&
+                !normalizedQuery.startsWith('DELETE') &&
+                !normalizedQuery.startsWith('INSERT')) {
+                return { status: 'error', error: 'EXPLAIN only supports SELECT, UPDATE, DELETE, and INSERT statements' };
+            }
+            let explainQuery = analyze ? 'EXPLAIN ANALYZE ' : 'EXPLAIN ';
+            if (format !== 'TRADITIONAL') {
+                explainQuery += `FORMAT=${format} `;
+            }
+            explainQuery += query;
+            const results = await this.db.query(explainQuery);
+            return {
+                status: 'success',
+                data: format === 'JSON' ? JSON.parse(results[0]['EXPLAIN']) : results,
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+        catch (error) {
+            return {
+                status: 'error',
+                error: error.message,
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+    }
+    /**
+     * Show engine status (InnoDB, etc.)
+     */
+    async showEngineStatus(params) {
+        try {
+            const engine = params?.engine || 'INNODB';
+            // Validate engine name
+            const validEngines = ['INNODB', 'PERFORMANCE_SCHEMA', 'NDB', 'NDBCLUSTER'];
+            if (!validEngines.includes(engine.toUpperCase())) {
+                return { status: 'error', error: `Invalid engine. Supported: ${validEngines.join(', ')}` };
+            }
+            const query = `SHOW ENGINE ${engine.toUpperCase()} STATUS`;
+            const results = await this.db.query(query);
+            return {
+                status: 'success',
+                data: results,
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+        catch (error) {
+            return {
+                status: 'error',
+                error: error.message,
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+    }
+    /**
+     * Get server information
+     */
+    async getServerInfo() {
+        try {
+            // Get various server info
+            const queries = [
+                { key: 'version', query: 'SELECT VERSION() as value' },
+                { key: 'connection_id', query: 'SELECT CONNECTION_ID() as value' },
+                { key: 'current_user', query: 'SELECT CURRENT_USER() as value' },
+                { key: 'database', query: 'SELECT DATABASE() as value' }
+            ];
+            const info = {};
+            for (const q of queries) {
+                const result = await this.db.query(q.query);
+                info[q.key] = result[0]?.value;
+            }
+            // Get uptime and other status
+            const statusQuery = `SHOW GLOBAL STATUS WHERE Variable_name IN ('Uptime', 'Threads_connected', 'Threads_running', 'Questions', 'Slow_queries', 'Opens', 'Flush_commands', 'Open_tables', 'Queries')`;
+            const statusResult = await this.db.query(statusQuery);
+            for (const row of statusResult) {
+                info[row.Variable_name.toLowerCase()] = row.Value;
+            }
+            // Format uptime
+            if (info.uptime) {
+                const uptimeSec = parseInt(info.uptime);
+                const days = Math.floor(uptimeSec / 86400);
+                const hours = Math.floor((uptimeSec % 86400) / 3600);
+                const minutes = Math.floor((uptimeSec % 3600) / 60);
+                info.uptime_formatted = `${days}d ${hours}h ${minutes}m`;
+            }
+            return {
+                status: 'success',
+                data: info,
+                queryLog: this.db.getFormattedQueryLogs(queries.length + 1)
+            };
+        }
+        catch (error) {
+            return {
+                status: 'error',
+                error: error.message,
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+    }
+    /**
+     * Show binary logs
+     */
+    async showBinaryLogs() {
+        try {
+            const query = 'SHOW BINARY LOGS';
+            const results = await this.db.query(query);
+            return {
+                status: 'success',
+                data: results,
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+        catch (error) {
+            return {
+                status: 'error',
+                error: error.message,
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+    }
+    /**
+     * Show master/replica status
+     */
+    async showReplicationStatus(params) {
+        try {
+            const type = params?.type || 'REPLICA';
+            let query;
+            if (type === 'MASTER') {
+                query = 'SHOW MASTER STATUS';
+            }
+            else {
+                // MySQL 8.0.22+ uses REPLICA, older versions use SLAVE
+                query = type === 'SLAVE' ? 'SHOW SLAVE STATUS' : 'SHOW REPLICA STATUS';
+            }
+            const results = await this.db.query(query);
+            return {
+                status: 'success',
+                data: results.length > 0 ? results[0] : null,
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+        catch (error) {
+            return {
+                status: 'error',
+                error: error.message,
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+    }
+}
+exports.ProcessTools = ProcessTools;

package/dist/tools/triggerTools.d.ts

@@ -0,0 +1,76 @@
+import { SecurityLayer } from '../security/securityLayer';
+export declare class TriggerTools {
+    private db;
+    private security;
+    constructor(security: SecurityLayer);
+    /**
+     * Validate database access - ensures only the connected database can be accessed
+     */
+    private validateDatabaseAccess;
+    /**
+     * List all triggers in the current database
+     */
+    listTriggers(params: {
+        database?: string;
+        table_name?: string;
+    }): Promise<{
+        status: string;
+        data?: any[];
+        error?: string;
+        queryLog?: string;
+    }>;
+    /**
+     * Get detailed information about a specific trigger
+     */
+    getTriggerInfo(params: {
+        trigger_name: string;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+    /**
+     * Create a new trigger
+     */
+    createTrigger(params: {
+        trigger_name: string;
+        table_name: string;
+        timing: 'BEFORE' | 'AFTER';
+        event: 'INSERT' | 'UPDATE' | 'DELETE';
+        body: string;
+        definer?: string;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+    /**
+     * Drop a trigger
+     */
+    dropTrigger(params: {
+        trigger_name: string;
+        if_exists?: boolean;
+        database?: string;
+    }): Promise<{
+        status: string;
+        message?: string;
+        error?: string;
+        queryLog?: string;
+    }>;
+    /**
+     * Show the CREATE statement for a trigger
+     */
+    showCreateTrigger(params: {
+        trigger_name: string;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+}

package/dist/tools/triggerTools.js

@@ -0,0 +1,294 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TriggerTools = void 0;
+const connection_1 = __importDefault(require("../db/connection"));
+const config_1 = require("../config/config");
+class TriggerTools {
+    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
+        };
+    }
+    /**
+     * List all triggers in the current database
+     */
+    async listTriggers(params) {
+        try {
+            const dbValidation = this.validateDatabaseAccess(params?.database);
+            if (!dbValidation.valid) {
+                return { status: 'error', error: dbValidation.error };
+            }
+            const database = dbValidation.database;
+            let query = `
+        SELECT
+          TRIGGER_NAME as trigger_name,
+          EVENT_MANIPULATION as event,
+          EVENT_OBJECT_TABLE as table_name,
+          ACTION_TIMING as timing,
+          ACTION_STATEMENT as statement,
+          ACTION_ORIENTATION as orientation,
+          DEFINER as definer,
+          CREATED as created
+        FROM INFORMATION_SCHEMA.TRIGGERS
+        WHERE TRIGGER_SCHEMA = ?
+      `;
+            const queryParams = [database];
+            if (params?.table_name) {
+                const identifierValidation = this.security.validateIdentifier(params.table_name);
+                if (!identifierValidation.valid) {
+                    return { status: 'error', error: identifierValidation.error || 'Invalid table name' };
+                }
+                query += ` AND EVENT_OBJECT_TABLE = ?`;
+                queryParams.push(params.table_name);
+            }
+            query += ` ORDER BY EVENT_OBJECT_TABLE, ACTION_TIMING, EVENT_MANIPULATION`;
+            const results = await this.db.query(query, queryParams);
+            return {
+                status: 'success',
+                data: results,
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+        catch (error) {
+            return {
+                status: 'error',
+                error: error.message,
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+    }
+    /**
+     * Get detailed information about a specific trigger
+     */
+    async getTriggerInfo(params) {
+        try {
+            const dbValidation = this.validateDatabaseAccess(params?.database);
+            if (!dbValidation.valid) {
+                return { status: 'error', error: dbValidation.error };
+            }
+            const { trigger_name } = params;
+            const database = dbValidation.database;
+            // Validate trigger name
+            const identifierValidation = this.security.validateIdentifier(trigger_name);
+            if (!identifierValidation.valid) {
+                return { status: 'error', error: identifierValidation.error || 'Invalid trigger name' };
+            }
+            const query = `
+        SELECT
+          TRIGGER_NAME as trigger_name,
+          EVENT_MANIPULATION as event,
+          EVENT_OBJECT_SCHEMA as schema_name,
+          EVENT_OBJECT_TABLE as table_name,
+          ACTION_ORDER as action_order,
+          ACTION_CONDITION as condition_value,
+          ACTION_STATEMENT as statement,
+          ACTION_ORIENTATION as orientation,
+          ACTION_TIMING as timing,
+          ACTION_REFERENCE_OLD_TABLE as old_table,
+          ACTION_REFERENCE_NEW_TABLE as new_table,
+          ACTION_REFERENCE_OLD_ROW as old_row,
+          ACTION_REFERENCE_NEW_ROW as new_row,
+          CREATED as created,
+          SQL_MODE as sql_mode,
+          DEFINER as definer,
+          CHARACTER_SET_CLIENT as charset,
+          COLLATION_CONNECTION as collation,
+          DATABASE_COLLATION as db_collation
+        FROM INFORMATION_SCHEMA.TRIGGERS
+        WHERE TRIGGER_SCHEMA = ? AND TRIGGER_NAME = ?
+      `;
+            const results = await this.db.query(query, [database, trigger_name]);
+            if (results.length === 0) {
+                return {
+                    status: 'error',
+                    error: `Trigger '${trigger_name}' not found in database '${database}'`,
+                    queryLog: this.db.getFormattedQueryLogs(1)
+                };
+            }
+            return {
+                status: 'success',
+                data: results[0],
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+        catch (error) {
+            return {
+                status: 'error',
+                error: error.message,
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+    }
+    /**
+     * Create a new trigger
+     */
+    async createTrigger(params) {
+        try {
+            const dbValidation = this.validateDatabaseAccess(params?.database);
+            if (!dbValidation.valid) {
+                return { status: 'error', error: dbValidation.error };
+            }
+            const { trigger_name, table_name, timing, event, body, definer } = params;
+            const database = dbValidation.database;
+            // Validate trigger name
+            const triggerValidation = this.security.validateIdentifier(trigger_name);
+            if (!triggerValidation.valid) {
+                return { status: 'error', error: triggerValidation.error || 'Invalid trigger name' };
+            }
+            // Validate table name
+            const tableValidation = this.security.validateIdentifier(table_name);
+            if (!tableValidation.valid) {
+                return { status: 'error', error: tableValidation.error || 'Invalid table name' };
+            }
+            // Validate timing
+            if (!['BEFORE', 'AFTER'].includes(timing)) {
+                return { status: 'error', error: 'Timing must be BEFORE or AFTER' };
+            }
+            // Validate event
+            if (!['INSERT', 'UPDATE', 'DELETE'].includes(event)) {
+                return { status: 'error', error: 'Event must be INSERT, UPDATE, or DELETE' };
+            }
+            // Build CREATE TRIGGER statement
+            let createQuery = 'CREATE';
+            if (definer) {
+                createQuery += ` DEFINER = ${definer}`;
+            }
+            createQuery += ` TRIGGER \`${database}\`.\`${trigger_name}\``;
+            createQuery += ` ${timing} ${event}`;
+            createQuery += ` ON \`${database}\`.\`${table_name}\``;
+            createQuery += ` FOR EACH ROW`;
+            // Check if body already contains BEGIN/END
+            const trimmedBody = body.trim();
+            if (trimmedBody.toUpperCase().startsWith('BEGIN') && trimmedBody.toUpperCase().endsWith('END')) {
+                createQuery += `\n${body}`;
+            }
+            else {
+                createQuery += `\nBEGIN\n${body}\nEND`;
+            }
+            await this.db.query(createQuery);
+            return {
+                status: 'success',
+                data: {
+                    message: `Trigger '${trigger_name}' created successfully`,
+                    trigger_name,
+                    table_name,
+                    timing,
+                    event,
+                    database
+                },
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+        catch (error) {
+            return {
+                status: 'error',
+                error: error.message,
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+    }
+    /**
+     * Drop a trigger
+     */
+    async dropTrigger(params) {
+        try {
+            const dbValidation = this.validateDatabaseAccess(params?.database);
+            if (!dbValidation.valid) {
+                return { status: 'error', error: dbValidation.error };
+            }
+            const { trigger_name, if_exists = false } = params;
+            const database = dbValidation.database;
+            // Validate trigger name
+            const identifierValidation = this.security.validateIdentifier(trigger_name);
+            if (!identifierValidation.valid) {
+                return { status: 'error', error: identifierValidation.error || 'Invalid trigger name' };
+            }
+            const dropQuery = `DROP TRIGGER ${if_exists ? 'IF EXISTS' : ''} \`${database}\`.\`${trigger_name}\``;
+            await this.db.query(dropQuery);
+            return {
+                status: 'success',
+                message: `Trigger '${trigger_name}' dropped successfully`,
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+        catch (error) {
+            return {
+                status: 'error',
+                error: error.message,
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+    }
+    /**
+     * Show the CREATE statement for a trigger
+     */
+    async showCreateTrigger(params) {
+        try {
+            const dbValidation = this.validateDatabaseAccess(params?.database);
+            if (!dbValidation.valid) {
+                return { status: 'error', error: dbValidation.error };
+            }
+            const { trigger_name } = params;
+            const database = dbValidation.database;
+            // Validate trigger name
+            const identifierValidation = this.security.validateIdentifier(trigger_name);
+            if (!identifierValidation.valid) {
+                return { status: 'error', error: identifierValidation.error || 'Invalid trigger name' };
+            }
+            const query = `SHOW CREATE TRIGGER \`${database}\`.\`${trigger_name}\``;
+            const results = await this.db.query(query);
+            if (results.length === 0) {
+                return {
+                    status: 'error',
+                    error: `Trigger '${trigger_name}' not found`,
+                    queryLog: this.db.getFormattedQueryLogs(1)
+                };
+            }
+            return {
+                status: 'success',
+                data: results[0],
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+        catch (error) {
+            return {
+                status: 'error',
+                error: error.message,
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+    }
+}
+exports.TriggerTools = TriggerTools;