@neverinfamous/mysql-mcp 2.1.0

package/src/adapters/mysql/tools/admin/index.ts

@@ -0,0 +1,77 @@
+/**
+ * MySQL Admin, Monitoring & Backup Tools
+ * 
+ * Database administration, monitoring, and backup operations.
+ * 17 tools total (6 admin + 7 monitoring + 4 backup).
+ */
+
+import type { MySQLAdapter } from '../../MySQLAdapter.js';
+import type { ToolDefinition } from '../../../../types/index.js';
+
+// Import from submodules
+import {
+    createOptimizeTableTool,
+    createAnalyzeTableTool,
+    createCheckTableTool,
+    createRepairTableTool,
+    createFlushTablesTool,
+    createKillQueryTool
+} from './maintenance.js';
+
+import {
+    createShowProcesslistTool,
+    createShowStatusTool,
+    createShowVariablesTool,
+    createInnodbStatusTool,
+    createReplicationStatusTool,
+    createPoolStatsTool,
+    createServerHealthTool
+} from './monitoring.js';
+
+import {
+    createExportTableTool,
+    createImportDataTool,
+    createCreateDumpTool,
+    createRestoreDumpTool
+} from './backup.js';
+
+/**
+ * Get admin tools
+ */
+export function getAdminTools(adapter: MySQLAdapter): ToolDefinition[] {
+    return [
+        createOptimizeTableTool(adapter),
+        createAnalyzeTableTool(adapter),
+        createCheckTableTool(adapter),
+        createRepairTableTool(adapter),
+        createFlushTablesTool(adapter),
+        createKillQueryTool(adapter)
+    ];
+}
+
+/**
+ * Get monitoring tools
+ */
+export function getMonitoringTools(adapter: MySQLAdapter): ToolDefinition[] {
+    return [
+        createShowProcesslistTool(adapter),
+        createShowStatusTool(adapter),
+        createShowVariablesTool(adapter),
+        createInnodbStatusTool(adapter),
+        createReplicationStatusTool(adapter),
+        createPoolStatsTool(adapter),
+        createServerHealthTool(adapter)
+    ];
+}
+
+/**
+ * Get backup tools
+ */
+export function getBackupTools(adapter: MySQLAdapter): ToolDefinition[] {
+    return [
+        createExportTableTool(adapter),
+        createImportDataTool(adapter),
+        createCreateDumpTool(adapter),
+        createRestoreDumpTool(adapter)
+    ];
+}

package/src/adapters/mysql/tools/admin/maintenance.ts

@@ -0,0 +1,160 @@
+/**
+ * MySQL Admin Tools - Table Maintenance
+ * 
+ * Tools for table maintenance operations.
+ * 6 tools: optimize, analyze, check, repair, flush, kill.
+ */
+
+import type { MySQLAdapter } from '../../MySQLAdapter.js';
+import type { ToolDefinition, RequestContext } from '../../../../types/index.js';
+import {
+    OptimizeTableSchema,
+    AnalyzeTableSchema,
+    CheckTableSchema,
+    FlushTablesSchema,
+    KillQuerySchema
+} from '../../types.js';
+import { z } from 'zod';
+
+export function createOptimizeTableTool(adapter: MySQLAdapter): ToolDefinition {
+    return {
+        name: 'mysql_optimize_table',
+        title: 'MySQL Optimize Table',
+        description: 'Optimize tables to reclaim unused space and defragment data.',
+        group: 'admin',
+        inputSchema: OptimizeTableSchema,
+        requiredScopes: ['admin'],
+        annotations: {
+            readOnlyHint: false,
+            idempotentHint: true
+        },
+        handler: async (params: unknown, _context: RequestContext) => {
+            const { tables } = OptimizeTableSchema.parse(params);
+            const tableList = tables.map(t => `\`${t}\``).join(', ');
+            const result = await adapter.executeQuery(`OPTIMIZE TABLE ${tableList}`);
+            return { results: result.rows };
+        }
+    };
+}
+
+export function createAnalyzeTableTool(adapter: MySQLAdapter): ToolDefinition {
+    return {
+        name: 'mysql_analyze_table',
+        title: 'MySQL Analyze Table',
+        description: 'Analyze tables to update index statistics for the query optimizer.',
+        group: 'admin',
+        inputSchema: AnalyzeTableSchema,
+        requiredScopes: ['admin'],
+        annotations: {
+            readOnlyHint: false,
+            idempotentHint: true
+        },
+        handler: async (params: unknown, _context: RequestContext) => {
+            const { tables } = AnalyzeTableSchema.parse(params);
+            const tableList = tables.map(t => `\`${t}\``).join(', ');
+            const result = await adapter.executeQuery(`ANALYZE TABLE ${tableList}`);
+            return { results: result.rows };
+        }
+    };
+}
+
+export function createCheckTableTool(adapter: MySQLAdapter): ToolDefinition {
+    return {
+        name: 'mysql_check_table',
+        title: 'MySQL Check Table',
+        description: 'Check tables for errors.',
+        group: 'admin',
+        inputSchema: CheckTableSchema,
+        requiredScopes: ['read'],
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true
+        },
+        handler: async (params: unknown, _context: RequestContext) => {
+            const { tables, option } = CheckTableSchema.parse(params);
+            const tableList = tables.map(t => `\`${t}\``).join(', ');
+            const optionClause = option ? ` ${option}` : '';
+            // Use rawQuery - CHECK TABLE not supported in prepared statement protocol
+            const result = await adapter.rawQuery(`CHECK TABLE ${tableList}${optionClause}`);
+            return {
+                results: result.rows ?? [],
+                rowCount: result.rows?.length ?? 0
+            };
+        }
+    };
+}
+
+export function createRepairTableTool(adapter: MySQLAdapter): ToolDefinition {
+    const schema = z.object({
+        tables: z.array(z.string()),
+        quick: z.boolean().optional().default(false)
+    });
+
+    return {
+        name: 'mysql_repair_table',
+        title: 'MySQL Repair Table',
+        description: 'Repair corrupted tables (MyISAM only).',
+        group: 'admin',
+        inputSchema: schema,
+        requiredScopes: ['admin'],
+        annotations: {
+            readOnlyHint: false,
+            idempotentHint: true
+        },
+        handler: async (params: unknown, _context: RequestContext) => {
+            const { tables, quick } = schema.parse(params);
+            const tableList = tables.map(t => `\`${t}\``).join(', ');
+            const quickClause = quick ? ' QUICK' : '';
+            const result = await adapter.executeQuery(`REPAIR TABLE ${tableList}${quickClause}`);
+            return { results: result.rows };
+        }
+    };
+}
+
+export function createFlushTablesTool(adapter: MySQLAdapter): ToolDefinition {
+    return {
+        name: 'mysql_flush_tables',
+        title: 'MySQL Flush Tables',
+        description: 'Flush tables to ensure data is written to disk.',
+        group: 'admin',
+        inputSchema: FlushTablesSchema,
+        requiredScopes: ['admin'],
+        annotations: {
+            readOnlyHint: false,
+            idempotentHint: true
+        },
+        handler: async (params: unknown, _context: RequestContext) => {
+            const { tables } = FlushTablesSchema.parse(params);
+
+            let sql = 'FLUSH TABLES';
+            if (tables && tables.length > 0) {
+                const tableList = tables.map(t => `\`${t}\``).join(', ');
+                sql = `FLUSH TABLES ${tableList}`;
+            }
+
+            await adapter.executeQuery(sql);
+            return { success: true };
+        }
+    };
+}
+
+export function createKillQueryTool(adapter: MySQLAdapter): ToolDefinition {
+    return {
+        name: 'mysql_kill_query',
+        title: 'MySQL Kill Query',
+        description: 'Kill a running query or connection.',
+        group: 'admin',
+        inputSchema: KillQuerySchema,
+        requiredScopes: ['admin'],
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true
+        },
+        handler: async (params: unknown, _context: RequestContext) => {
+            const { processId, connection } = KillQuerySchema.parse(params);
+            const killType = connection ? 'CONNECTION' : 'QUERY';
+            await adapter.executeQuery(`KILL ${killType} ${processId}`);
+            return { success: true, killed: processId, type: killType };
+        }
+    };
+}

package/src/adapters/mysql/tools/admin/monitoring.ts

@@ -0,0 +1,229 @@
+/**
+ * MySQL Admin Tools - Monitoring
+ * 
+ * Tools for server and performance monitoring.
+ * 7 tools: processlist, status, variables, innodb_status, replication, pool_stats, health.
+ */
+
+import type { MySQLAdapter } from '../../MySQLAdapter.js';
+import type { ToolDefinition, RequestContext } from '../../../../types/index.js';
+import {
+    ShowProcesslistSchema,
+    ShowStatusSchema,
+    ShowVariablesSchema
+} from '../../types.js';
+import { z } from 'zod';
+
+export function createShowProcesslistTool(adapter: MySQLAdapter): ToolDefinition {
+    return {
+        name: 'mysql_show_processlist',
+        title: 'MySQL Show Processlist',
+        description: 'Show all running processes and queries.',
+        group: 'monitoring',
+        inputSchema: ShowProcesslistSchema,
+        requiredScopes: ['read'],
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true
+        },
+        handler: async (params: unknown, _context: RequestContext) => {
+            const { full } = ShowProcesslistSchema.parse(params);
+            const sql = full ? 'SHOW FULL PROCESSLIST' : 'SHOW PROCESSLIST';
+            const result = await adapter.executeQuery(sql);
+            return { processes: result.rows };
+        }
+    };
+}
+
+export function createShowStatusTool(adapter: MySQLAdapter): ToolDefinition {
+    return {
+        name: 'mysql_show_status',
+        title: 'MySQL Show Status',
+        description: 'Show server status variables.',
+        group: 'monitoring',
+        inputSchema: ShowStatusSchema,
+        requiredScopes: ['read'],
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true
+        },
+        handler: async (params: unknown, _context: RequestContext) => {
+            const { like, global } = ShowStatusSchema.parse(params);
+
+            let sql = global ? 'SHOW GLOBAL STATUS' : 'SHOW STATUS';
+
+            // SHOW commands don't support parameter binding - build SQL directly
+            if (like) {
+                // Escape the like pattern for safety
+                const escapedLike = like.replace(/'/g, "''");
+                sql += ` LIKE '${escapedLike}'`;
+            }
+
+            const result = await adapter.rawQuery(sql);
+
+            // Convert to object for easier use
+            // Handle both uppercase and Pascal case column names
+            const status: Record<string, string> = {};
+            for (const row of result.rows ?? []) {
+                const name = (row['Variable_name'] ?? row['VARIABLE_NAME'] ?? row['variable_name']) as string;
+                const value = (row['Value'] ?? row['VALUE'] ?? row['value']) as string;
+                if (name) {
+                    status[name] = value;
+                }
+            }
+
+            return { status, rowCount: result.rows?.length ?? 0 };
+        }
+    };
+}
+
+export function createShowVariablesTool(adapter: MySQLAdapter): ToolDefinition {
+    return {
+        name: 'mysql_show_variables',
+        title: 'MySQL Show Variables',
+        description: 'Show server configuration variables.',
+        group: 'monitoring',
+        inputSchema: ShowVariablesSchema,
+        requiredScopes: ['read'],
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true
+        },
+        handler: async (params: unknown, _context: RequestContext) => {
+            const { like, global } = ShowVariablesSchema.parse(params);
+
+            let sql = global ? 'SHOW GLOBAL VARIABLES' : 'SHOW VARIABLES';
+
+            // SHOW commands don't support parameter binding - build SQL directly
+            if (like) {
+                // Escape the like pattern for safety
+                const escapedLike = like.replace(/'/g, "''");
+                sql += ` LIKE '${escapedLike}'`;
+            }
+
+            const result = await adapter.rawQuery(sql);
+
+            // Convert to object
+            // Handle both uppercase and Pascal case column names
+            const variables: Record<string, string> = {};
+            for (const row of result.rows ?? []) {
+                const name = (row['Variable_name'] ?? row['VARIABLE_NAME'] ?? row['variable_name']) as string;
+                const value = (row['Value'] ?? row['VALUE'] ?? row['value']) as string;
+                if (name) {
+                    variables[name] = value;
+                }
+            }
+
+            return { variables, rowCount: result.rows?.length ?? 0 };
+        }
+    };
+}
+
+export function createInnodbStatusTool(adapter: MySQLAdapter): ToolDefinition {
+    const schema = z.object({});
+
+    return {
+        name: 'mysql_innodb_status',
+        title: 'MySQL InnoDB Status',
+        description: 'Get detailed InnoDB engine status.',
+        group: 'monitoring',
+        inputSchema: schema,
+        requiredScopes: ['read'],
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true
+        },
+        handler: async (_params: unknown, _context: RequestContext) => {
+            const result = await adapter.executeQuery('SHOW ENGINE INNODB STATUS');
+            return { status: result.rows?.[0] };
+        }
+    };
+}
+
+export function createReplicationStatusTool(adapter: MySQLAdapter): ToolDefinition {
+    const schema = z.object({});
+
+    return {
+        name: 'mysql_replication_status',
+        title: 'MySQL Replication Status',
+        description: 'Show replication slave/replica status.',
+        group: 'monitoring',
+        inputSchema: schema,
+        requiredScopes: ['read'],
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true
+        },
+        handler: async (_params: unknown, _context: RequestContext) => {
+            // Try both old and new syntax
+            try {
+                const result = await adapter.executeQuery('SHOW REPLICA STATUS');
+                return { status: result.rows?.[0] };
+            } catch {
+                const result = await adapter.executeQuery('SHOW SLAVE STATUS');
+                return { status: result.rows?.[0] };
+            }
+        }
+    };
+}
+
+export function createPoolStatsTool(adapter: MySQLAdapter): ToolDefinition {
+    const schema = z.object({});
+
+    return {
+        name: 'mysql_pool_stats',
+        title: 'MySQL Pool Stats',
+        description: 'Get connection pool statistics.',
+        group: 'monitoring',
+        inputSchema: schema,
+        requiredScopes: ['read'],
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true
+        },
+        handler: async (_params: unknown, _context: RequestContext) => {
+            const pool = await Promise.resolve(adapter.getPool());
+            if (!pool) {
+                return { error: 'Pool not available' };
+            }
+            return { poolStats: pool.getStats() };
+        }
+    };
+}
+
+export function createServerHealthTool(adapter: MySQLAdapter): ToolDefinition {
+    const schema = z.object({});
+
+    return {
+        name: 'mysql_server_health',
+        title: 'MySQL Server Health',
+        description: 'Get comprehensive server health information.',
+        group: 'monitoring',
+        inputSchema: schema,
+        requiredScopes: ['read'],
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true
+        },
+        handler: async (_params: unknown, _context: RequestContext) => {
+            const health = await adapter.getHealth();
+
+            // Get additional metrics
+            const uptimeResult = await adapter.executeQuery("SHOW GLOBAL STATUS LIKE 'Uptime'");
+            const uptime = uptimeResult.rows?.[0]?.['Value'];
+
+            const connectionsResult = await adapter.executeQuery("SHOW GLOBAL STATUS LIKE 'Threads_connected'");
+            const connections = connectionsResult.rows?.[0]?.['Value'];
+
+            const queriesResult = await adapter.executeQuery("SHOW GLOBAL STATUS LIKE 'Questions'");
+            const queries = queriesResult.rows?.[0]?.['Value'];
+
+            return {
+                ...health,
+                uptime: (uptime != null && typeof uptime === 'string') ? parseInt(uptime, 10) : undefined,
+                activeConnections: (connections != null && typeof connections === 'string') ? parseInt(connections, 10) : undefined,
+                totalQueries: (queries != null && typeof queries === 'string') ? parseInt(queries, 10) : undefined
+            };
+        }
+    };
+}

package/src/adapters/mysql/tools/cluster/__tests__/group-replication.test.ts

@@ -0,0 +1,204 @@
+
+import { describe, it, expect, vi, beforeEach, type Mock } from 'vitest';
+import {
+    createGRStatusTool,
+    createGRFlowControlTool
+} from '../group-replication.js';
+import { MySQLAdapter } from '../../../MySQLAdapter.js';
+
+describe('Group Replication Tools', () => {
+    let mockAdapter: MySQLAdapter;
+    let mockExecuteQuery: Mock;
+
+    beforeEach(() => {
+        mockExecuteQuery = vi.fn();
+        mockAdapter = {
+            executeQuery: mockExecuteQuery
+        } as unknown as MySQLAdapter;
+    });
+
+    describe('mysql_gr_status', () => {
+        it('should report status correctly', async () => {
+            const tool = createGRStatusTool(mockAdapter);
+
+            mockExecuteQuery
+                // Plugin Status
+                .mockResolvedValueOnce({
+                    rows: [{ PLUGIN_STATUS: 'ACTIVE' }]
+                })
+                // Config status
+                .mockResolvedValueOnce({
+                    rows: [{
+                        groupName: 'd747d0cc-189f-11ee-8653-0242ac110002',
+                        singlePrimaryMode: 1,
+                        localAddress: '127.0.0.1:33061',
+                        groupSeeds: '127.0.0.1:33061',
+                        bootstrapGroup: 0
+                    }]
+                })
+                // Members status
+                .mockResolvedValueOnce({
+                    rows: [{
+                        CHANNEL_NAME: 'group_replication_applier',
+                        MEMBER_ID: 'member-1',
+                        MEMBER_HOST: 'host1',
+                        MEMBER_PORT: 3306,
+                        MEMBER_STATE: 'ONLINE',
+                        MEMBER_ROLE: 'PRIMARY',
+                        MEMBER_VERSION: '8.0.32'
+                    }]
+                })
+                // Local UUID
+                .mockResolvedValueOnce({
+                    rows: [{ serverUuid: 'member-1' }]
+                });
+
+            const result = await tool.handler({}, {} as any) as any;
+
+            expect(result).toEqual({
+                enabled: true,
+                groupName: 'd747d0cc-189f-11ee-8653-0242ac110002',
+                singlePrimaryMode: true,
+                localAddress: '127.0.0.1:33061',
+                localMember: {
+                    CHANNEL_NAME: 'group_replication_applier',
+                    MEMBER_ID: 'member-1',
+                    MEMBER_HOST: 'host1',
+                    MEMBER_PORT: 3306,
+                    MEMBER_STATE: 'ONLINE',
+                    MEMBER_ROLE: 'PRIMARY',
+                    MEMBER_VERSION: '8.0.32'
+                },
+                memberCount: 1,
+                members: [expect.objectContaining({
+                    id: 'member-1',
+                    role: 'PRIMARY'
+                })]
+            });
+        });
+
+        it('should handle disabled group replication', async () => {
+            const tool = createGRStatusTool(mockAdapter);
+
+            mockExecuteQuery
+                .mockResolvedValueOnce({ rows: [] }); // Plugin not found or not active
+
+            const result = await tool.handler({}, {} as any) as any;
+
+            expect(result.enabled).toBe(false);
+            expect(result.message).toContain('not active');
+        });
+
+        it('should handle partial status where config is missing but members exist', async () => {
+            const tool = createGRStatusTool(mockAdapter);
+
+            mockExecuteQuery
+                // Plugin Status
+                .mockResolvedValueOnce({
+                    rows: [{ PLUGIN_STATUS: 'ACTIVE' }]
+                })
+                .mockResolvedValueOnce({ rows: [] }) // Config missing
+                .mockResolvedValueOnce({
+                    rows: [{ MEMBER_ID: 'member-1', MEMBER_STATE: 'ONLINE' }]
+                }) // Members exist
+                .mockResolvedValueOnce({
+                    rows: [{ serverUuid: 'member-1' }]
+                });
+
+            const result = await tool.handler({}, {} as any) as any;
+
+            expect(result.enabled).toBe(true);
+            expect(result.groupName).toBeNull();
+            expect(result.singlePrimaryMode).toBe(false); // Default logic fallback
+            expect(result.localMember).toBeDefined();
+        });
+    });
+
+    describe('mysql_gr_flow_control', () => {
+        it('should report flow control statistics', async () => {
+            const tool = createGRFlowControlTool(mockAdapter);
+
+            mockExecuteQuery
+                // Plugin Status
+                .mockResolvedValueOnce({
+                    rows: [{ PLUGIN_STATUS: 'ACTIVE' }]
+                })
+                // Config
+                .mockResolvedValueOnce({
+                    rows: [{
+                        flowControlMode: 'QUOTA',
+                        certifierThreshold: 25000,
+                        applierThreshold: 25000,
+                        minQuota: 0,
+                        minRecoveryQuota: 0,
+                        maxQuota: 0
+                    }]
+                })
+                // Queue stats
+                .mockResolvedValueOnce({
+                    rows: [{
+                        memberId: 'member-1',
+                        certifyQueue: 100,
+                        applierQueue: 50
+                    }]
+                });
+
+            const result = await tool.handler({}, {} as any) as any;
+
+            expect(result.isThrottling).toBe(false);
+            expect(result.memberQueues).toHaveLength(1);
+        });
+
+        it('should detect throttling', async () => {
+            const tool = createGRFlowControlTool(mockAdapter);
+
+            mockExecuteQuery
+                // Plugin Status
+                .mockResolvedValueOnce({
+                    rows: [{ PLUGIN_STATUS: 'ACTIVE' }]
+                })
+                // Config
+                .mockResolvedValueOnce({
+                    rows: [{
+                        certifierThreshold: 100, // Low threshold
+                        applierThreshold: 100
+                    }]
+                })
+                // Queue stats
+                .mockResolvedValueOnce({
+                    rows: [{
+                        memberId: 'member-1',
+                        certifyQueue: 200, // Above threshold
+                        applierQueue: 50
+                    }]
+                });
+
+            const result = await tool.handler({}, {} as any) as any;
+
+            expect(result.isThrottling).toBe(true);
+        });
+
+        it('should use default thresholds when config missing', async () => {
+            const tool = createGRFlowControlTool(mockAdapter);
+
+            mockExecuteQuery
+                // Plugin Status
+                .mockResolvedValueOnce({
+                    rows: [{ PLUGIN_STATUS: 'ACTIVE' }]
+                })
+                .mockResolvedValueOnce({ rows: [] }) // Missing config
+                .mockResolvedValueOnce({
+                    rows: [{
+                        memberId: 'member-1',
+                        certifyQueue: 26000, // > 25000 default
+                        applierQueue: 100
+                    }]
+                });
+
+            const result = await tool.handler({}, {} as any) as any;
+
+            expect(result.isThrottling).toBe(true);
+            expect(result.recommendation).toContain('Flow control is active');
+        });
+    });
+});