@berthojoris/mcp-mysql-server 1.4.15 → 1.6.0

package/dist/mcp-server.js

@@ -316,7 +316,7 @@ const TOOLS = [
     },
     {
         name: "run_query",
-        description: "Runs a read-only SQL SELECT query with optional parameters. Only SELECT statements are allowed.",
+        description: "Runs a read-only SQL SELECT query with optional parameters, optimizer hints, and caching support. Only SELECT statements are allowed.",
         inputSchema: {
             type: "object",
             properties: {
@@ -329,6 +329,50 @@ const TOOLS = [
                     description: "Optional array of parameters for parameterized queries",
                     items: {},
                 },
+                hints: {
+                    type: "object",
+                    description: "Optional MySQL optimizer hints to apply to the query",
+                    properties: {
+                        maxExecutionTime: {
+                            type: "number",
+                            description: "Maximum execution time in milliseconds",
+                        },
+                        forceIndex: {
+                            oneOf: [
+                                { type: "string" },
+                                { type: "array", items: { type: "string" } },
+                            ],
+                            description: "Force usage of specific index(es)",
+                        },
+                        ignoreIndex: {
+                            oneOf: [
+                                { type: "string" },
+                                { type: "array", items: { type: "string" } },
+                            ],
+                            description: "Ignore specific index(es)",
+                        },
+                        straightJoin: {
+                            type: "boolean",
+                            description: "Use STRAIGHT_JOIN to force join order",
+                        },
+                        noCache: {
+                            type: "boolean",
+                            description: "Disable query cache for this query",
+                        },
+                        sqlBigResult: {
+                            type: "boolean",
+                            description: "Optimize for large result sets",
+                        },
+                        sqlSmallResult: {
+                            type: "boolean",
+                            description: "Optimize for small result sets",
+                        },
+                    },
+                },
+                useCache: {
+                    type: "boolean",
+                    description: "Whether to use query result caching (default: true)",
+                },
             },
             required: ["query"],
         },
@@ -806,126 +850,1310 @@ const TOOLS = [
             required: ["query"],
         },
     },
-];
-// Create the MCP server
-const server = new index_js_1.Server({
-    name: "mysql-mcp-server",
-    version: "1.4.4",
-}, {
-    capabilities: {
-        tools: {},
+    // Cache Management Tools
+    {
+        name: "get_cache_stats",
+        description: "Get query cache statistics including hit rate, size, and configuration.",
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
     },
-});
-// Handle list tools request
-server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
-    return {
-        tools: TOOLS,
-    };
-});
-// Handle tool call requests
-server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-    try {
-        let result;
-        switch (name) {
-            case "list_databases":
-                result = await mysqlMCP.listDatabases();
-                break;
-            case "list_tables":
-                result = await mysqlMCP.listTables((args || {}));
-                break;
-            case "read_table_schema":
-                result = await mysqlMCP.readTableSchema((args || {}));
-                break;
-            case "create_record":
-                result = await mysqlMCP.createRecord((args || {}));
-                break;
-            case "read_records":
-                result = await mysqlMCP.readRecords((args || {}));
-                break;
-            case "update_record":
-                result = await mysqlMCP.updateRecord((args || {}));
-                break;
-            case "delete_record":
-                result = await mysqlMCP.deleteRecord((args || {}));
-                break;
-            case "bulk_insert":
-                result = await mysqlMCP.bulkInsert((args || {}));
-                break;
-            case "bulk_update":
-                result = await mysqlMCP.bulkUpdate((args || {}));
-                break;
-            case "bulk_delete":
-                result = await mysqlMCP.bulkDelete((args || {}));
-                break;
-            case "run_query":
-                result = await mysqlMCP.runQuery((args || {}));
-                break;
-            case "execute_sql":
-                result = await mysqlMCP.executeSql((args || {}));
-                break;
-            case "create_table":
-                result = await mysqlMCP.createTable(args || {});
-                break;
-            case "alter_table":
-                result = await mysqlMCP.alterTable(args || {});
-                break;
-            case "drop_table":
-                result = await mysqlMCP.dropTable(args || {});
-                break;
-            case "execute_ddl":
-                result = await mysqlMCP.executeDdl((args || {}));
-                break;
-            case "describe_connection":
-                result = await mysqlMCP.describeConnection();
-                break;
-            case "test_connection":
-                result = await mysqlMCP.testConnection();
-                break;
-            case "get_table_relationships":
-                result = await mysqlMCP.getTableRelationships((args || {}));
-                break;
-            // Transaction Tools
-            case "begin_transaction":
-                result = await mysqlMCP.beginTransaction((args || {}));
-                break;
-            case "commit_transaction":
-                result = await mysqlMCP.commitTransaction((args || {}));
-                break;
-            case "rollback_transaction":
-                result = await mysqlMCP.rollbackTransaction((args || {}));
-                break;
-            case "get_transaction_status":
-                result = await mysqlMCP.getTransactionStatus();
-                break;
-            case "execute_in_transaction":
-                result = await mysqlMCP.executeInTransaction((args || {}));
-                break;
-            // Stored Procedure Tools
-            case "list_stored_procedures":
-                result = await mysqlMCP.listStoredProcedures((args || {}));
-                break;
-            case "get_stored_procedure_info":
-                result = await mysqlMCP.getStoredProcedureInfo((args || {}));
-                break;
-            case "execute_stored_procedure":
-                result = await mysqlMCP.executeStoredProcedure((args || {}));
-                break;
-            case "create_stored_procedure":
-                result = await mysqlMCP.createStoredProcedure((args || {}));
-                break;
-            case "drop_stored_procedure":
-                result = await mysqlMCP.dropStoredProcedure((args || {}));
-                break;
-            case "show_create_procedure":
-                result = await mysqlMCP.showCreateProcedure((args || {}));
-                break;
-            // Data Export Tools
-            case "export_table_to_csv":
-                result = await mysqlMCP.exportTableToCSV((args || {}));
-                break;
-            case "export_query_to_csv":
-                result = await mysqlMCP.exportQueryToCSV((args || {}));
+    {
+        name: "get_cache_config",
+        description: "Get current cache configuration settings.",
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+    },
+    {
+        name: "configure_cache",
+        description: "Configure cache settings including TTL, max size, and enable/disable.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                enabled: {
+                    type: "boolean",
+                    description: "Enable or disable the query cache",
+                },
+                ttlMs: {
+                    type: "number",
+                    description: "Cache time-to-live in milliseconds (default: 60000)",
+                },
+                maxSize: {
+                    type: "number",
+                    description: "Maximum number of cached entries (default: 100)",
+                },
+                maxMemoryMB: {
+                    type: "number",
+                    description: "Maximum memory usage in MB (default: 50)",
+                },
+            },
+        },
+    },
+    {
+        name: "clear_cache",
+        description: "Clear all entries from the query cache.",
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+    },
+    {
+        name: "invalidate_table_cache",
+        description: "Invalidate all cached queries related to a specific table.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                table_name: {
+                    type: "string",
+                    description: "Name of the table to invalidate cache for",
+                },
+            },
+            required: ["table_name"],
+        },
+    },
+    // Query Optimization Tools
+    {
+        name: "analyze_query",
+        description: "Analyze a SQL query and get optimization suggestions including recommended indexes and hints.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: {
+                    type: "string",
+                    description: "SQL query to analyze",
+                },
+            },
+            required: ["query"],
+        },
+    },
+    {
+        name: "get_optimization_hints",
+        description: "Get suggested MySQL optimizer hints for a specific optimization goal (SPEED, MEMORY, or STABILITY).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                goal: {
+                    type: "string",
+                    enum: ["SPEED", "MEMORY", "STABILITY"],
+                    description: "Optimization goal: SPEED for faster queries, MEMORY for lower memory usage, STABILITY for consistent performance",
+                },
+            },
+            required: ["goal"],
+        },
+    },
+    // View Tools
+    {
+        name: "list_views",
+        description: "Lists all views in the connected database.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+        },
+    },
+    {
+        name: "get_view_info",
+        description: "Gets detailed information about a specific view including columns and definition.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                view_name: { type: "string", description: "Name of the view" },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["view_name"],
+        },
+    },
+    {
+        name: "create_view",
+        description: "Creates a new view with the specified SELECT definition. Requires 'ddl' permission.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                view_name: {
+                    type: "string",
+                    description: "Name of the view to create",
+                },
+                definition: {
+                    type: "string",
+                    description: "SELECT statement that defines the view",
+                },
+                or_replace: {
+                    type: "boolean",
+                    description: "If true, replaces existing view",
+                },
+                algorithm: {
+                    type: "string",
+                    enum: ["UNDEFINED", "MERGE", "TEMPTABLE"],
+                    description: "View algorithm",
+                },
+                security: {
+                    type: "string",
+                    enum: ["DEFINER", "INVOKER"],
+                    description: "Security context",
+                },
+                check_option: {
+                    type: "string",
+                    enum: ["CASCADED", "LOCAL"],
+                    description: "Check option for updatable views",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["view_name", "definition"],
+        },
+    },
+    {
+        name: "alter_view",
+        description: "Alters an existing view definition. Requires 'ddl' permission.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                view_name: { type: "string", description: "Name of the view to alter" },
+                definition: {
+                    type: "string",
+                    description: "New SELECT statement that defines the view",
+                },
+                algorithm: {
+                    type: "string",
+                    enum: ["UNDEFINED", "MERGE", "TEMPTABLE"],
+                    description: "View algorithm",
+                },
+                security: {
+                    type: "string",
+                    enum: ["DEFINER", "INVOKER"],
+                    description: "Security context",
+                },
+                check_option: {
+                    type: "string",
+                    enum: ["CASCADED", "LOCAL"],
+                    description: "Check option",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["view_name", "definition"],
+        },
+    },
+    {
+        name: "drop_view",
+        description: "Drops a view. Requires 'ddl' permission. WARNING: This is irreversible!",
+        inputSchema: {
+            type: "object",
+            properties: {
+                view_name: { type: "string", description: "Name of the view to drop" },
+                if_exists: {
+                    type: "boolean",
+                    description: "If true, will not error if view does not exist",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["view_name"],
+        },
+    },
+    {
+        name: "show_create_view",
+        description: "Shows the CREATE statement for a view.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                view_name: { type: "string", description: "Name of the view" },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["view_name"],
+        },
+    },
+    // Trigger Tools
+    {
+        name: "list_triggers",
+        description: "Lists all triggers in the database, optionally filtered by table.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+                table_name: {
+                    type: "string",
+                    description: "Optional: filter triggers for specific table",
+                },
+            },
+        },
+    },
+    {
+        name: "get_trigger_info",
+        description: "Gets detailed information about a specific trigger.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                trigger_name: { type: "string", description: "Name of the trigger" },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["trigger_name"],
+        },
+    },
+    {
+        name: "create_trigger",
+        description: "Creates a new trigger on a table. Requires 'ddl' permission.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                trigger_name: { type: "string", description: "Name of the trigger" },
+                table_name: {
+                    type: "string",
+                    description: "Table the trigger is associated with",
+                },
+                timing: {
+                    type: "string",
+                    enum: ["BEFORE", "AFTER"],
+                    description: "When the trigger fires",
+                },
+                event: {
+                    type: "string",
+                    enum: ["INSERT", "UPDATE", "DELETE"],
+                    description: "Event that fires the trigger",
+                },
+                body: { type: "string", description: "SQL statements to execute" },
+                definer: {
+                    type: "string",
+                    description: "Optional: user who owns the trigger",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["trigger_name", "table_name", "timing", "event", "body"],
+        },
+    },
+    {
+        name: "drop_trigger",
+        description: "Drops a trigger. Requires 'ddl' permission. WARNING: This is irreversible!",
+        inputSchema: {
+            type: "object",
+            properties: {
+                trigger_name: {
+                    type: "string",
+                    description: "Name of the trigger to drop",
+                },
+                if_exists: {
+                    type: "boolean",
+                    description: "If true, will not error if trigger does not exist",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["trigger_name"],
+        },
+    },
+    {
+        name: "show_create_trigger",
+        description: "Shows the CREATE statement for a trigger.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                trigger_name: { type: "string", description: "Name of the trigger" },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["trigger_name"],
+        },
+    },
+    // Function Tools
+    {
+        name: "list_functions",
+        description: "Lists all user-defined functions in the database.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+        },
+    },
+    {
+        name: "get_function_info",
+        description: "Gets detailed information about a specific function including parameters.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                function_name: { type: "string", description: "Name of the function" },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["function_name"],
+        },
+    },
+    {
+        name: "create_function",
+        description: "Creates a new user-defined function. Requires 'ddl' permission.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                function_name: { type: "string", description: "Name of the function" },
+                parameters: {
+                    type: "array",
+                    description: "Array of parameter definitions",
+                    items: {
+                        type: "object",
+                        properties: {
+                            name: { type: "string" },
+                            data_type: { type: "string" },
+                        },
+                        required: ["name", "data_type"],
+                    },
+                },
+                returns: { type: "string", description: "Return data type" },
+                body: { type: "string", description: "Function body (SQL statements)" },
+                deterministic: {
+                    type: "boolean",
+                    description: "Whether function always returns same result for same input",
+                },
+                data_access: {
+                    type: "string",
+                    enum: [
+                        "CONTAINS SQL",
+                        "NO SQL",
+                        "READS SQL DATA",
+                        "MODIFIES SQL DATA",
+                    ],
+                },
+                security: { type: "string", enum: ["DEFINER", "INVOKER"] },
+                comment: { type: "string", description: "Optional comment" },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["function_name", "returns", "body"],
+        },
+    },
+    {
+        name: "drop_function",
+        description: "Drops a user-defined function. Requires 'ddl' permission.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                function_name: {
+                    type: "string",
+                    description: "Name of the function to drop",
+                },
+                if_exists: {
+                    type: "boolean",
+                    description: "If true, will not error if function does not exist",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["function_name"],
+        },
+    },
+    {
+        name: "show_create_function",
+        description: "Shows the CREATE statement for a function.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                function_name: { type: "string", description: "Name of the function" },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["function_name"],
+        },
+    },
+    {
+        name: "execute_function",
+        description: "Executes a user-defined function and returns its result.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                function_name: {
+                    type: "string",
+                    description: "Name of the function to execute",
+                },
+                parameters: {
+                    type: "array",
+                    description: "Array of parameter values",
+                    items: {},
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["function_name"],
+        },
+    },
+    // Index Tools
+    {
+        name: "list_indexes",
+        description: "Lists all indexes for a specific table.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                table_name: { type: "string", description: "Name of the table" },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["table_name"],
+        },
+    },
+    {
+        name: "get_index_info",
+        description: "Gets detailed information about a specific index.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                table_name: { type: "string", description: "Name of the table" },
+                index_name: { type: "string", description: "Name of the index" },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["table_name", "index_name"],
+        },
+    },
+    {
+        name: "create_index",
+        description: "Creates a new index on a table. Requires 'ddl' permission.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                table_name: { type: "string", description: "Name of the table" },
+                index_name: { type: "string", description: "Name of the index" },
+                columns: {
+                    type: "array",
+                    description: "Columns to index (string or object with column, length, order)",
+                    items: {},
+                },
+                unique: { type: "boolean", description: "Whether index is unique" },
+                index_type: {
+                    type: "string",
+                    enum: ["BTREE", "HASH", "FULLTEXT", "SPATIAL"],
+                    description: "Index type",
+                },
+                comment: { type: "string", description: "Optional comment" },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["table_name", "index_name", "columns"],
+        },
+    },
+    {
+        name: "drop_index",
+        description: "Drops an index from a table. Requires 'ddl' permission.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                table_name: { type: "string", description: "Name of the table" },
+                index_name: {
+                    type: "string",
+                    description: "Name of the index to drop",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["table_name", "index_name"],
+        },
+    },
+    {
+        name: "analyze_index",
+        description: "Analyzes a table to update index statistics.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                table_name: {
+                    type: "string",
+                    description: "Name of the table to analyze",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["table_name"],
+        },
+    },
+    // Constraint Tools
+    {
+        name: "list_foreign_keys",
+        description: "Lists all foreign key constraints for a table.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                table_name: { type: "string", description: "Name of the table" },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["table_name"],
+        },
+    },
+    {
+        name: "list_constraints",
+        description: "Lists all constraints (PRIMARY KEY, FOREIGN KEY, UNIQUE, CHECK) for a table.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                table_name: { type: "string", description: "Name of the table" },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["table_name"],
+        },
+    },
+    {
+        name: "add_foreign_key",
+        description: "Adds a foreign key constraint to a table. Requires 'ddl' permission.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                table_name: { type: "string", description: "Name of the table" },
+                constraint_name: {
+                    type: "string",
+                    description: "Name of the constraint",
+                },
+                columns: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Columns in the foreign key",
+                },
+                referenced_table: {
+                    type: "string",
+                    description: "Referenced table name",
+                },
+                referenced_columns: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Referenced columns",
+                },
+                on_delete: {
+                    type: "string",
+                    enum: ["CASCADE", "SET NULL", "RESTRICT", "NO ACTION", "SET DEFAULT"],
+                },
+                on_update: {
+                    type: "string",
+                    enum: ["CASCADE", "SET NULL", "RESTRICT", "NO ACTION", "SET DEFAULT"],
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: [
+                "table_name",
+                "constraint_name",
+                "columns",
+                "referenced_table",
+                "referenced_columns",
+            ],
+        },
+    },
+    {
+        name: "drop_foreign_key",
+        description: "Drops a foreign key constraint. Requires 'ddl' permission.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                table_name: { type: "string", description: "Name of the table" },
+                constraint_name: {
+                    type: "string",
+                    description: "Name of the constraint to drop",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["table_name", "constraint_name"],
+        },
+    },
+    {
+        name: "add_unique_constraint",
+        description: "Adds a unique constraint to a table. Requires 'ddl' permission.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                table_name: { type: "string", description: "Name of the table" },
+                constraint_name: {
+                    type: "string",
+                    description: "Name of the constraint",
+                },
+                columns: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Columns in the unique constraint",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["table_name", "constraint_name", "columns"],
+        },
+    },
+    {
+        name: "drop_constraint",
+        description: "Drops a UNIQUE or CHECK constraint. Requires 'ddl' permission.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                table_name: { type: "string", description: "Name of the table" },
+                constraint_name: {
+                    type: "string",
+                    description: "Name of the constraint",
+                },
+                constraint_type: {
+                    type: "string",
+                    enum: ["UNIQUE", "CHECK"],
+                    description: "Type of constraint",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["table_name", "constraint_name", "constraint_type"],
+        },
+    },
+    {
+        name: "add_check_constraint",
+        description: "Adds a CHECK constraint to a table (MySQL 8.0.16+). Requires 'ddl' permission.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                table_name: { type: "string", description: "Name of the table" },
+                constraint_name: {
+                    type: "string",
+                    description: "Name of the constraint",
+                },
+                expression: {
+                    type: "string",
+                    description: "Check expression (e.g., 'age >= 18')",
+                },
+                enforced: {
+                    type: "boolean",
+                    description: "Whether constraint is enforced (default: true)",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["table_name", "constraint_name", "expression"],
+        },
+    },
+    // Table Maintenance Tools
+    {
+        name: "analyze_table",
+        description: "Analyzes a table to update index statistics for the query optimizer.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                table_name: {
+                    type: "string",
+                    description: "Name of the table to analyze",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["table_name"],
+        },
+    },
+    {
+        name: "optimize_table",
+        description: "Optimizes a table to reclaim unused space and defragment data.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                table_name: {
+                    type: "string",
+                    description: "Name of the table to optimize",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["table_name"],
+        },
+    },
+    {
+        name: "check_table",
+        description: "Checks a table for errors.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                table_name: {
+                    type: "string",
+                    description: "Name of the table to check",
+                },
+                check_type: {
+                    type: "string",
+                    enum: ["QUICK", "FAST", "MEDIUM", "EXTENDED", "CHANGED"],
+                    description: "Type of check",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["table_name"],
+        },
+    },
+    {
+        name: "repair_table",
+        description: "Repairs a corrupted table (MyISAM, ARCHIVE, CSV only).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                table_name: {
+                    type: "string",
+                    description: "Name of the table to repair",
+                },
+                quick: { type: "boolean", description: "Quick repair" },
+                extended: { type: "boolean", description: "Extended repair" },
+                use_frm: { type: "boolean", description: "Use .frm file to repair" },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["table_name"],
+        },
+    },
+    {
+        name: "truncate_table",
+        description: "Truncates a table (removes all rows quickly). Requires 'ddl' permission. WARNING: This is irreversible!",
+        inputSchema: {
+            type: "object",
+            properties: {
+                table_name: {
+                    type: "string",
+                    description: "Name of the table to truncate",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["table_name"],
+        },
+    },
+    {
+        name: "get_table_status",
+        description: "Gets detailed status and statistics for one or all tables.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                table_name: {
+                    type: "string",
+                    description: "Optional: specific table name (omit for all tables)",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+        },
+    },
+    {
+        name: "flush_table",
+        description: "Flushes table(s) - closes and reopens them.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                table_name: {
+                    type: "string",
+                    description: "Optional: specific table (omit for all tables)",
+                },
+                with_read_lock: {
+                    type: "boolean",
+                    description: "Acquire read lock after flushing",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+        },
+    },
+    {
+        name: "get_table_size",
+        description: "Gets size information for one or all tables including data and index sizes.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                table_name: {
+                    type: "string",
+                    description: "Optional: specific table name (omit for all tables)",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+        },
+    },
+    // Process Management Tools
+    {
+        name: "show_process_list",
+        description: "Shows all running MySQL processes/connections.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                full: { type: "boolean", description: "Show full query text" },
+            },
+        },
+    },
+    {
+        name: "kill_process",
+        description: "Kills a MySQL process/connection by ID.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                process_id: { type: "number", description: "Process ID to kill" },
+                type: {
+                    type: "string",
+                    enum: ["CONNECTION", "QUERY"],
+                    description: "Kill connection or just query",
+                },
+            },
+            required: ["process_id"],
+        },
+    },
+    {
+        name: "show_status",
+        description: "Shows MySQL server status variables.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                like: {
+                    type: "string",
+                    description: "Optional: filter pattern (e.g., 'Thread%')",
+                },
+                global: {
+                    type: "boolean",
+                    description: "Show global status instead of session",
+                },
+            },
+        },
+    },
+    {
+        name: "show_variables",
+        description: "Shows MySQL server configuration variables.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                like: {
+                    type: "string",
+                    description: "Optional: filter pattern (e.g., 'max_%')",
+                },
+                global: {
+                    type: "boolean",
+                    description: "Show global variables instead of session",
+                },
+            },
+        },
+    },
+    {
+        name: "explain_query",
+        description: "Shows the execution plan for a query (EXPLAIN).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: { type: "string", description: "SQL query to explain" },
+                format: {
+                    type: "string",
+                    enum: ["TRADITIONAL", "JSON", "TREE"],
+                    description: "Output format",
+                },
+                analyze: {
+                    type: "boolean",
+                    description: "Actually execute the query and show real statistics",
+                },
+            },
+            required: ["query"],
+        },
+    },
+    {
+        name: "show_engine_status",
+        description: "Shows storage engine status (InnoDB by default).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                engine: {
+                    type: "string",
+                    description: "Engine name (INNODB, PERFORMANCE_SCHEMA, etc.)",
+                },
+            },
+        },
+    },
+    {
+        name: "get_server_info",
+        description: "Gets comprehensive MySQL server information including version, uptime, and statistics.",
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+    },
+    {
+        name: "show_binary_logs",
+        description: "Shows binary log files on the server.",
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+    },
+    {
+        name: "show_replication_status",
+        description: "Shows replication status (master or replica).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                type: {
+                    type: "string",
+                    enum: ["MASTER", "REPLICA", "SLAVE"],
+                    description: "Which status to show",
+                },
+            },
+        },
+    },
+];
+// Create the MCP server
+const server = new index_js_1.Server({
+    name: "mysql-mcp-server",
+    version: "1.4.4",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+// Handle list tools request
+server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
+    return {
+        tools: TOOLS,
+    };
+});
+// Handle tool call requests
+server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        let result;
+        switch (name) {
+            case "list_databases":
+                result = await mysqlMCP.listDatabases();
+                break;
+            case "list_tables":
+                result = await mysqlMCP.listTables((args || {}));
+                break;
+            case "read_table_schema":
+                result = await mysqlMCP.readTableSchema((args || {}));
+                break;
+            case "create_record":
+                result = await mysqlMCP.createRecord((args || {}));
+                break;
+            case "read_records":
+                result = await mysqlMCP.readRecords((args || {}));
+                break;
+            case "update_record":
+                result = await mysqlMCP.updateRecord((args || {}));
+                break;
+            case "delete_record":
+                result = await mysqlMCP.deleteRecord((args || {}));
+                break;
+            case "bulk_insert":
+                result = await mysqlMCP.bulkInsert((args || {}));
+                break;
+            case "bulk_update":
+                result = await mysqlMCP.bulkUpdate((args || {}));
+                break;
+            case "bulk_delete":
+                result = await mysqlMCP.bulkDelete((args || {}));
+                break;
+            case "run_query":
+                result = await mysqlMCP.runQuery((args || {}));
+                break;
+            case "execute_sql":
+                result = await mysqlMCP.executeSql((args || {}));
+                break;
+            case "create_table":
+                result = await mysqlMCP.createTable(args || {});
+                break;
+            case "alter_table":
+                result = await mysqlMCP.alterTable(args || {});
+                break;
+            case "drop_table":
+                result = await mysqlMCP.dropTable(args || {});
+                break;
+            case "execute_ddl":
+                result = await mysqlMCP.executeDdl((args || {}));
+                break;
+            case "describe_connection":
+                result = await mysqlMCP.describeConnection();
+                break;
+            case "test_connection":
+                result = await mysqlMCP.testConnection();
+                break;
+            case "get_table_relationships":
+                result = await mysqlMCP.getTableRelationships((args || {}));
+                break;
+            // Transaction Tools
+            case "begin_transaction":
+                result = await mysqlMCP.beginTransaction((args || {}));
+                break;
+            case "commit_transaction":
+                result = await mysqlMCP.commitTransaction((args || {}));
+                break;
+            case "rollback_transaction":
+                result = await mysqlMCP.rollbackTransaction((args || {}));
+                break;
+            case "get_transaction_status":
+                result = await mysqlMCP.getTransactionStatus();
+                break;
+            case "execute_in_transaction":
+                result = await mysqlMCP.executeInTransaction((args || {}));
+                break;
+            // Stored Procedure Tools
+            case "list_stored_procedures":
+                result = await mysqlMCP.listStoredProcedures((args || {}));
+                break;
+            case "get_stored_procedure_info":
+                result = await mysqlMCP.getStoredProcedureInfo((args || {}));
+                break;
+            case "execute_stored_procedure":
+                result = await mysqlMCP.executeStoredProcedure((args || {}));
+                break;
+            case "create_stored_procedure":
+                result = await mysqlMCP.createStoredProcedure((args || {}));
+                break;
+            case "drop_stored_procedure":
+                result = await mysqlMCP.dropStoredProcedure((args || {}));
+                break;
+            case "show_create_procedure":
+                result = await mysqlMCP.showCreateProcedure((args || {}));
+                break;
+            // Data Export Tools
+            case "export_table_to_csv":
+                result = await mysqlMCP.exportTableToCSV((args || {}));
+                break;
+            case "export_query_to_csv":
+                result = await mysqlMCP.exportQueryToCSV((args || {}));
+                break;
+            // Cache Management Tools
+            case "get_cache_stats":
+                result = mysqlMCP.getCacheStats();
+                break;
+            case "get_cache_config":
+                result = mysqlMCP.getCacheConfig();
+                break;
+            case "configure_cache":
+                result = mysqlMCP.configureCacheSettings((args || {}));
+                break;
+            case "clear_cache":
+                result = mysqlMCP.clearCache();
+                break;
+            case "invalidate_table_cache":
+                result = mysqlMCP.invalidateCacheForTable((args || {}));
+                break;
+            // Query Optimization Tools
+            case "analyze_query":
+                result = mysqlMCP.analyzeQuery((args || {}));
+                break;
+            case "get_optimization_hints":
+                result = mysqlMCP.getOptimizationHints((args || {}));
+                break;
+            // View Tools
+            case "list_views":
+                result = await mysqlMCP.listViews((args || {}));
+                break;
+            case "get_view_info":
+                result = await mysqlMCP.getViewInfo((args || {}));
+                break;
+            case "create_view":
+                result = await mysqlMCP.createView((args || {}));
+                break;
+            case "alter_view":
+                result = await mysqlMCP.alterView((args || {}));
+                break;
+            case "drop_view":
+                result = await mysqlMCP.dropView((args || {}));
+                break;
+            case "show_create_view":
+                result = await mysqlMCP.showCreateView((args || {}));
+                break;
+            // Trigger Tools
+            case "list_triggers":
+                result = await mysqlMCP.listTriggers((args || {}));
+                break;
+            case "get_trigger_info":
+                result = await mysqlMCP.getTriggerInfo((args || {}));
+                break;
+            case "create_trigger":
+                result = await mysqlMCP.createTrigger((args || {}));
+                break;
+            case "drop_trigger":
+                result = await mysqlMCP.dropTrigger((args || {}));
+                break;
+            case "show_create_trigger":
+                result = await mysqlMCP.showCreateTrigger((args || {}));
+                break;
+            // Function Tools
+            case "list_functions":
+                result = await mysqlMCP.listFunctions((args || {}));
+                break;
+            case "get_function_info":
+                result = await mysqlMCP.getFunctionInfo((args || {}));
+                break;
+            case "create_function":
+                result = await mysqlMCP.createFunction((args || {}));
+                break;
+            case "drop_function":
+                result = await mysqlMCP.dropFunction((args || {}));
+                break;
+            case "show_create_function":
+                result = await mysqlMCP.showCreateFunction((args || {}));
+                break;
+            case "execute_function":
+                result = await mysqlMCP.executeFunction((args || {}));
+                break;
+            // Index Tools
+            case "list_indexes":
+                result = await mysqlMCP.listIndexes((args || {}));
+                break;
+            case "get_index_info":
+                result = await mysqlMCP.getIndexInfo((args || {}));
+                break;
+            case "create_index":
+                result = await mysqlMCP.createIndex((args || {}));
+                break;
+            case "drop_index":
+                result = await mysqlMCP.dropIndex((args || {}));
+                break;
+            case "analyze_index":
+                result = await mysqlMCP.analyzeIndex((args || {}));
+                break;
+            // Constraint Tools
+            case "list_foreign_keys":
+                result = await mysqlMCP.listForeignKeys((args || {}));
+                break;
+            case "list_constraints":
+                result = await mysqlMCP.listConstraints((args || {}));
+                break;
+            case "add_foreign_key":
+                result = await mysqlMCP.addForeignKey((args || {}));
+                break;
+            case "drop_foreign_key":
+                result = await mysqlMCP.dropForeignKey((args || {}));
+                break;
+            case "add_unique_constraint":
+                result = await mysqlMCP.addUniqueConstraint((args || {}));
+                break;
+            case "drop_constraint":
+                result = await mysqlMCP.dropConstraint((args || {}));
+                break;
+            case "add_check_constraint":
+                result = await mysqlMCP.addCheckConstraint((args || {}));
+                break;
+            // Table Maintenance Tools
+            case "analyze_table":
+                result = await mysqlMCP.analyzeTable((args || {}));
+                break;
+            case "optimize_table":
+                result = await mysqlMCP.optimizeTable((args || {}));
+                break;
+            case "check_table":
+                result = await mysqlMCP.checkTable((args || {}));
+                break;
+            case "repair_table":
+                result = await mysqlMCP.repairTable((args || {}));
+                break;
+            case "truncate_table":
+                result = await mysqlMCP.truncateTable((args || {}));
+                break;
+            case "get_table_status":
+                result = await mysqlMCP.getTableStatus((args || {}));
+                break;
+            case "flush_table":
+                result = await mysqlMCP.flushTable((args || {}));
+                break;
+            case "get_table_size":
+                result = await mysqlMCP.getTableSize((args || {}));
+                break;
+            // Process Management Tools
+            case "show_process_list":
+                result = await mysqlMCP.showProcessList((args || {}));
+                break;
+            case "kill_process":
+                result = await mysqlMCP.killProcess((args || {}));
+                break;
+            case "show_status":
+                result = await mysqlMCP.showStatus((args || {}));
+                break;
+            case "show_variables":
+                result = await mysqlMCP.showVariables((args || {}));
+                break;
+            case "explain_query":
+                result = await mysqlMCP.explainQuery((args || {}));
+                break;
+            case "show_engine_status":
+                result = await mysqlMCP.showEngineStatus((args || {}));
+                break;
+            case "get_server_info":
+                result = await mysqlMCP.getServerInfo();
+                break;
+            case "show_binary_logs":
+                result = await mysqlMCP.showBinaryLogs();
+                break;
+            case "show_replication_status":
+                result = await mysqlMCP.showReplicationStatus((args || {}));
                 break;
             default:
                 throw new Error(`Unknown tool: ${name}`);
@@ -933,8 +2161,8 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
         // Handle the result based on status
         if (result.status === "error") {
             // Include query log in error response if available
-            let errorText = `Error: ${result.error}`;
-            if ('queryLog' in result && result.queryLog) {
+            let errorText = `Error: ${"error" in result ? result.error : "Unknown error"}`;
+            if ("queryLog" in result && result.queryLog) {
                 errorText += `\n\n${result.queryLog}`;
             }
             return {
@@ -975,11 +2203,11 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
         }
         // NEW APPROACH: Wrap the data with SQL query as part of the response structure
         // This forces the LLM to see and describe the SQL query as part of the data
-        if ('queryLog' in result && result.queryLog) {
+        if ("queryLog" in result && result.queryLog) {
             const wrappedResponse = {
                 "⚠️ IMPORTANT_INSTRUCTION_TO_ASSISTANT": "ALWAYS display the SQL query execution details below to the user in your response. This is critical information that users need to see.",
                 "⚠️ SQL_QUERY_EXECUTED": result.queryLog,
-                "📊 RESULTS": responseData
+                "📊 RESULTS": responseData,
             };
             return {
                 content: [