@neverinfamous/mysql-mcp 2.1.0

package/src/adapters/mysql/tools/schema/routines.ts

@@ -0,0 +1,106 @@
+import { z } from 'zod';
+import type { MySQLAdapter } from '../../MySQLAdapter.js';
+import type { ToolDefinition, RequestContext } from '../../../../types/index.js';
+
+const ListObjectsSchema = z.object({
+    schema: z.string().optional().describe('Schema name (defaults to current database)'),
+    type: z.enum(['PROCEDURE', 'FUNCTION']).optional().describe('Filter by type')
+});
+
+/**
+ * List stored procedures
+ */
+export function createListStoredProceduresTool(adapter: MySQLAdapter): ToolDefinition {
+    return {
+        name: 'mysql_list_stored_procedures',
+        title: 'MySQL List Stored Procedures',
+        description: 'List all stored procedures with parameters and metadata.',
+        group: 'schema',
+        inputSchema: ListObjectsSchema,
+        requiredScopes: ['read'],
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true
+        },
+        handler: async (params: unknown, _context: RequestContext) => {
+            const { schema } = ListObjectsSchema.parse(params);
+
+            const query = `
+                SELECT 
+                    r.ROUTINE_NAME as name,
+                    r.ROUTINE_TYPE as type,
+                    r.DEFINER as definer,
+                    r.CREATED as created,
+                    r.LAST_ALTERED as lastAltered,
+                    r.SQL_DATA_ACCESS as dataAccess,
+                    r.SECURITY_TYPE as securityType,
+                    r.ROUTINE_COMMENT as comment,
+                    GROUP_CONCAT(
+                        CONCAT(p.PARAMETER_MODE, ' ', p.PARAMETER_NAME, ' ', p.DATA_TYPE)
+                        ORDER BY p.ORDINAL_POSITION
+                        SEPARATOR ', '
+                    ) as parameters
+                FROM information_schema.ROUTINES r
+                LEFT JOIN information_schema.PARAMETERS p 
+                    ON r.ROUTINE_SCHEMA = p.SPECIFIC_SCHEMA 
+                    AND r.ROUTINE_NAME = p.SPECIFIC_NAME
+                    AND p.PARAMETER_MODE IS NOT NULL
+                WHERE r.ROUTINE_SCHEMA = COALESCE(?, DATABASE())
+                  AND r.ROUTINE_TYPE = 'PROCEDURE'
+                GROUP BY r.ROUTINE_NAME, r.ROUTINE_TYPE, r.DEFINER, r.CREATED, 
+                         r.LAST_ALTERED, r.SQL_DATA_ACCESS, r.SECURITY_TYPE, r.ROUTINE_COMMENT
+                ORDER BY r.ROUTINE_NAME
+            `;
+
+            const result = await adapter.executeQuery(query, [schema ?? null]);
+            return {
+                procedures: result.rows,
+                count: result.rows?.length ?? 0
+            };
+        }
+    };
+}
+
+/**
+ * List user-defined functions
+ */
+export function createListFunctionsTool(adapter: MySQLAdapter): ToolDefinition {
+    return {
+        name: 'mysql_list_functions',
+        title: 'MySQL List Functions',
+        description: 'List all user-defined functions with return types and metadata.',
+        group: 'schema',
+        inputSchema: ListObjectsSchema,
+        requiredScopes: ['read'],
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true
+        },
+        handler: async (params: unknown, _context: RequestContext) => {
+            const { schema } = ListObjectsSchema.parse(params);
+
+            const query = `
+                SELECT 
+                    r.ROUTINE_NAME as name,
+                    r.DATA_TYPE as returnType,
+                    r.DEFINER as definer,
+                    r.CREATED as created,
+                    r.LAST_ALTERED as lastAltered,
+                    r.SQL_DATA_ACCESS as dataAccess,
+                    r.SECURITY_TYPE as securityType,
+                    r.ROUTINE_COMMENT as comment,
+                    r.IS_DETERMINISTIC as isDeterministic
+                FROM information_schema.ROUTINES r
+                WHERE r.ROUTINE_SCHEMA = COALESCE(?, DATABASE())
+                  AND r.ROUTINE_TYPE = 'FUNCTION'
+                ORDER BY r.ROUTINE_NAME
+            `;
+
+            const result = await adapter.executeQuery(query, [schema ?? null]);
+            return {
+                functions: result.rows,
+                count: result.rows?.length ?? 0
+            };
+        }
+    };
+}

package/src/adapters/mysql/tools/schema/scheduled_events.ts

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+import type { MySQLAdapter } from '../../MySQLAdapter.js';
+import type { ToolDefinition, RequestContext } from '../../../../types/index.js';
+
+const ListEventsSchema = z.object({
+    schema: z.string().optional().describe('Schema name (defaults to current database)'),
+    status: z.enum(['ENABLED', 'DISABLED', 'SLAVESIDE_DISABLED']).optional().describe('Filter by status')
+});
+
+/**
+ * List scheduled events
+ */
+export function createListEventsTool(adapter: MySQLAdapter): ToolDefinition {
+    return {
+        name: 'mysql_list_events',
+        title: 'MySQL List Events',
+        description: 'List all scheduled events with execution status and schedule info.',
+        group: 'schema',
+        inputSchema: ListEventsSchema,
+        requiredScopes: ['read'],
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true
+        },
+        handler: async (params: unknown, _context: RequestContext) => {
+            const { schema, status } = ListEventsSchema.parse(params);
+
+            let query = `
+                SELECT 
+                    EVENT_NAME as name,
+                    EVENT_SCHEMA as schemaName,
+                    DEFINER as definer,
+                    TIME_ZONE as timeZone,
+                    EVENT_TYPE as eventType,
+                    EXECUTE_AT as executeAt,
+                    INTERVAL_VALUE as intervalValue,
+                    INTERVAL_FIELD as intervalField,
+                    STARTS as starts,
+                    ENDS as ends,
+                    STATUS as status,
+                    ON_COMPLETION as onCompletion,
+                    CREATED as created,
+                    LAST_ALTERED as lastAltered,
+                    LAST_EXECUTED as lastExecuted,
+                    EVENT_COMMENT as comment
+                FROM information_schema.EVENTS
+                WHERE EVENT_SCHEMA = COALESCE(?, DATABASE())
+            `;
+
+            const queryParams: unknown[] = [schema ?? null];
+
+            if (status) {
+                query += ' AND STATUS = ?';
+                queryParams.push(status);
+            }
+
+            query += ' ORDER BY EVENT_NAME';
+
+            const result = await adapter.executeQuery(query, queryParams);
+            return {
+                events: result.rows,
+                count: result.rows?.length ?? 0
+            };
+        }
+    };
+}

package/src/adapters/mysql/tools/schema/triggers.ts

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+import type { MySQLAdapter } from '../../MySQLAdapter.js';
+import type { ToolDefinition, RequestContext } from '../../../../types/index.js';
+
+const ListTriggersSchema = z.object({
+    table: z.string().optional().describe('Filter by table name'),
+    schema: z.string().optional().describe('Schema name (defaults to current database)')
+});
+
+/**
+ * List triggers
+ */
+export function createListTriggersTool(adapter: MySQLAdapter): ToolDefinition {
+    return {
+        name: 'mysql_list_triggers',
+        title: 'MySQL List Triggers',
+        description: 'List all triggers with event timing, action, and definition.',
+        group: 'schema',
+        inputSchema: ListTriggersSchema,
+        requiredScopes: ['read'],
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true
+        },
+        handler: async (params: unknown, _context: RequestContext) => {
+            const { table, schema } = ListTriggersSchema.parse(params);
+
+            let query = `
+                SELECT 
+                    TRIGGER_NAME as name,
+                    EVENT_OBJECT_TABLE as tableName,
+                    EVENT_MANIPULATION as event,
+                    ACTION_TIMING as timing,
+                    ACTION_STATEMENT as statement,
+                    DEFINER as definer,
+                    CREATED as created
+                FROM information_schema.TRIGGERS
+                WHERE TRIGGER_SCHEMA = COALESCE(?, DATABASE())
+            `;
+
+            const queryParams: unknown[] = [schema ?? null];
+
+            if (table) {
+                query += ' AND EVENT_OBJECT_TABLE = ?';
+                queryParams.push(table);
+            }
+
+            query += ' ORDER BY EVENT_OBJECT_TABLE, ACTION_TIMING, EVENT_MANIPULATION';
+
+            const result = await adapter.executeQuery(query, queryParams);
+            return {
+                triggers: result.rows,
+                count: result.rows?.length ?? 0
+            };
+        }
+    };
+}

package/src/adapters/mysql/tools/schema/views.ts

@@ -0,0 +1,90 @@
+import { z } from 'zod';
+import type { MySQLAdapter } from '../../MySQLAdapter.js';
+import type { ToolDefinition, RequestContext } from '../../../../types/index.js';
+import { validateQualifiedIdentifier, escapeQualifiedTable } from '../../../../utils/validators.js';
+
+const ListViewsSchema = z.object({
+    schema: z.string().optional().describe('Schema name (defaults to current database)')
+});
+
+const CreateViewSchema = z.object({
+    name: z.string().describe('View name'),
+    definition: z.string().describe('SELECT statement defining the view'),
+    orReplace: z.boolean().default(false).describe('Use CREATE OR REPLACE'),
+    algorithm: z.enum(['UNDEFINED', 'MERGE', 'TEMPTABLE']).default('UNDEFINED').describe('View algorithm'),
+    checkOption: z.enum(['NONE', 'CASCADED', 'LOCAL']).default('NONE').describe('WITH CHECK OPTION')
+});
+
+/**
+ * List all views
+ */
+export function createListViewsTool(adapter: MySQLAdapter): ToolDefinition {
+    return {
+        name: 'mysql_list_views',
+        title: 'MySQL List Views',
+        description: 'List all views with their definitions, security type, and check option.',
+        group: 'schema',
+        inputSchema: ListViewsSchema,
+        requiredScopes: ['read'],
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true
+        },
+        handler: async (params: unknown, _context: RequestContext) => {
+            const { schema } = ListViewsSchema.parse(params);
+
+            const query = `
+                SELECT 
+                    TABLE_NAME as name,
+                    VIEW_DEFINITION as definition,
+                    DEFINER as definer,
+                    SECURITY_TYPE as securityType,
+                    CHECK_OPTION as checkOption,
+                    IS_UPDATABLE as isUpdatable
+                FROM information_schema.VIEWS
+                WHERE TABLE_SCHEMA = COALESCE(?, DATABASE())
+                ORDER BY TABLE_NAME
+            `;
+
+            const result = await adapter.executeQuery(query, [schema ?? null]);
+            return {
+                views: result.rows,
+                count: result.rows?.length ?? 0
+            };
+        }
+    };
+}
+
+/**
+ * Create a view
+ */
+export function createCreateViewTool(adapter: MySQLAdapter): ToolDefinition {
+    return {
+        name: 'mysql_create_view',
+        title: 'MySQL Create View',
+        description: 'Create or replace a view with specified algorithm and check option.',
+        group: 'schema',
+        inputSchema: CreateViewSchema,
+        requiredScopes: ['write'],
+        annotations: {
+            readOnlyHint: false
+        },
+        handler: async (params: unknown, _context: RequestContext) => {
+            const { name, definition, orReplace, algorithm, checkOption } = CreateViewSchema.parse(params);
+
+            validateQualifiedIdentifier(name, 'view');
+
+            const fullViewName = escapeQualifiedTable(name);
+
+            const createClause = orReplace ? 'CREATE OR REPLACE' : 'CREATE';
+            let sql = `${createClause} ALGORITHM=${algorithm} VIEW ${fullViewName} AS ${definition}`;
+
+            if (checkOption !== 'NONE') {
+                sql += ` WITH ${checkOption} CHECK OPTION`;
+            }
+
+            await adapter.executeQuery(sql);
+            return { success: true, viewName: name };
+        }
+    };
+}

package/src/adapters/mysql/tools/security/__tests__/audit.test.ts

@@ -0,0 +1,181 @@
+/**
+ * mysql-mcp - Security Audit Tools Unit Tests
+ * 
+ * Comprehensive tests for audit.ts module functions.
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import {
+    createSecurityAuditTool,
+    createSecurityFirewallStatusTool,
+    createSecurityFirewallRulesTool
+} from '../audit.js';
+import type { MySQLAdapter } from '../../../MySQLAdapter.js';
+import { createMockMySQLAdapter, createMockRequestContext, createMockQueryResult } from '../../../../../__tests__/mocks/index.js';
+
+describe('Security Audit Tools', () => {
+    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+    let mockContext: ReturnType<typeof createMockRequestContext>;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockAdapter = createMockMySQLAdapter();
+        mockContext = createMockRequestContext();
+    });
+
+    describe('createSecurityAuditTool', () => {
+        it('should query mysql.audit_log if available', async () => {
+            // Mock table check
+            mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([{ TABLE_NAME: 'audit_log' }]));
+
+            // Mock log query
+            mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+                { user: 'test', event_type: 'LOGIN' }
+            ]));
+
+            const tool = createSecurityAuditTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({
+                limit: 10,
+                user: 'test'
+            }, mockContext) as { source: string, events: any[] };
+
+            expect(mockAdapter.executeQuery).toHaveBeenCalledTimes(2);
+            expect(result.source).toBe('mysql.audit_log');
+            expect(result.events).toHaveLength(1);
+
+            const queryCall = mockAdapter.executeQuery.mock.calls[1][0] as string;
+            expect(queryCall).toContain('FROM mysql.audit_log');
+            expect(queryCall).toContain('WHERE user LIKE ?');
+            expect(queryCall).toContain('WHERE user LIKE ?');
+        });
+
+        it('should apply all filters in normal mode', async () => {
+            mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([{ TABLE_NAME: 'audit_log' }]));
+            mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
+
+            const tool = createSecurityAuditTool(mockAdapter as unknown as MySQLAdapter);
+            await tool.handler({
+                limit: 10,
+                user: 'test',
+                eventType: 'LOGIN',
+                startTime: '2023-01-01'
+            }, mockContext);
+
+            const queryCall = mockAdapter.executeQuery.mock.calls[1][0] as string;
+            const queryParams = mockAdapter.executeQuery.mock.calls[1][1] as any[];
+
+            expect(queryCall).toContain('user LIKE ?');
+            expect(queryCall).toContain('event_type = ?');
+            expect(queryCall).toContain('timestamp >= ?');
+            expect(queryParams).toHaveLength(3);
+        });
+
+        it('should fallback to performance_schema if audit_log is missing', async () => {
+            // Mock table check - empty result
+            mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
+
+            // Mock fallback query
+            mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+                { event: 'select' }
+            ]));
+
+            const tool = createSecurityAuditTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({
+                limit: 10
+            }, mockContext) as { source: string };
+
+            expect(result.source).toBe('performance_schema');
+
+            const queryCall = mockAdapter.executeQuery.mock.calls[1][0] as string;
+            expect(queryCall).toContain('FROM performance_schema.events_statements_history');
+            expect(queryCall).toContain('FROM performance_schema.events_statements_history');
+        });
+
+        it('should apply user filter in fallback mode', async () => {
+            mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([])); // No audit log
+            mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
+
+            const tool = createSecurityAuditTool(mockAdapter as unknown as MySQLAdapter);
+            await tool.handler({
+                limit: 10,
+                user: 'test_user'
+            }, mockContext);
+
+            const queryCall = mockAdapter.executeQuery.mock.calls[1][0] as string;
+            const queryParams = mockAdapter.executeQuery.mock.calls[1][1] as any[];
+
+            expect(queryCall).toContain('CURRENT_USER LIKE ?');
+            expect(queryParams[0]).toContain('test_user');
+        });
+
+        it('should handle error when checking audit log', async () => {
+            mockAdapter.executeQuery.mockRejectedValue(new Error('Access denied'));
+
+            const tool = createSecurityAuditTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({}, mockContext) as { available: boolean };
+
+            expect(result.available).toBe(false);
+        });
+    });
+
+    describe('createSecurityFirewallStatusTool', () => {
+        it('should check firewall status when installed', async () => {
+            // Mock plugin check
+            mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+                { PLUGIN_NAME: 'mysql_firewall', PLUGIN_STATUS: 'ACTIVE' }
+            ]));
+
+            // Mock variables check
+            mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+                { Variable_name: 'mysql_firewall_mode', Value: 'ON' }
+            ]));
+
+            const tool = createSecurityFirewallStatusTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({}, mockContext) as { installed: boolean, configuration: any };
+
+            expect(result.installed).toBe(true);
+            expect(result.configuration).toHaveProperty('mysql_firewall_mode', 'ON');
+        });
+
+        it('should report not installed if plugin missing', async () => {
+            mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
+
+            const tool = createSecurityFirewallStatusTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({}, mockContext) as { installed: boolean };
+
+            expect(result.installed).toBe(false);
+        });
+    });
+
+    describe('createSecurityFirewallRulesTool', () => {
+        it('should list firewall rules', async () => {
+            // Mock users query
+            mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+                { USERHOST: 'user@%', MODE: 'PROTECTING' }
+            ]));
+
+            // Mock rules query
+            mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+                { USERHOST: 'user@%', RULE: 'SELECT *' }
+            ]));
+
+            const tool = createSecurityFirewallRulesTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({
+                user: 'user'
+            }, mockContext) as { users: any[], rules: any[] };
+
+            expect(mockAdapter.executeQuery).toHaveBeenCalledTimes(2);
+            expect(result.users).toHaveLength(1);
+            expect(result.rules).toHaveLength(1);
+        });
+
+        it('should handle errors gracefully', async () => {
+            mockAdapter.executeQuery.mockRejectedValue(new Error('Table missing'));
+
+            const tool = createSecurityFirewallRulesTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({}, mockContext) as { available: boolean };
+
+            expect(result.available).toBe(false);
+        });
+    });
+});

package/src/adapters/mysql/tools/security/__tests__/data-protection.test.ts

@@ -0,0 +1,111 @@
+/**
+ * mysql-mcp - Security Data Protection Tools Unit Tests
+ * 
+ * Comprehensive tests for data-protection.ts module functions.
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import {
+    createSecurityMaskDataTool,
+    createSecurityUserPrivilegesTool,
+    createSecuritySensitiveTablesTool
+} from '../data-protection.js';
+import type { MySQLAdapter } from '../../MySQLAdapter.js';
+import { createMockMySQLAdapter, createMockRequestContext, createMockQueryResult } from '../../../../../__tests__/mocks/index.js';
+
+describe('Security Data Protection Tools', () => {
+    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+    let mockContext: ReturnType<typeof createMockRequestContext>;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockAdapter = createMockMySQLAdapter();
+        mockContext = createMockRequestContext();
+    });
+
+    describe('createSecurityMaskDataTool', () => {
+        it('should mask email addresses', async () => {
+            const tool = createSecurityMaskDataTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({
+                value: 'john.doe@example.com',
+                type: 'email'
+            }, mockContext) as { masked: string };
+
+            expect(result.masked).toBe('j******e@example.com');
+        });
+
+        it('should mask phone numbers', async () => {
+            const tool = createSecurityMaskDataTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({
+                value: '555-123-4567',
+                type: 'phone'
+            }, mockContext) as { masked: string };
+
+            expect(result.masked).toBe('******4567');
+        });
+
+        it('should mask partial text', async () => {
+            const tool = createSecurityMaskDataTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({
+                value: 'sensitive data',
+                type: 'partial',
+                keepFirst: 2,
+                keepLast: 2
+            }, mockContext) as { masked: string };
+
+            expect(result.masked).toBe('se**********ta');
+        });
+    });
+
+    describe('createSecurityUserPrivilegesTool', () => {
+        it('should get user privileges and roles', async () => {
+            // Mock users query
+            mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+                { User: 'john', Host: 'localhost', authPlugin: 'native', accountLocked: 'N', passwordExpired: 'N' }
+            ]));
+
+            // Mock permissions query for john
+            mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+                { 'Grants for john@localhost': 'GRANT ALL PRIVILEGES ON *.* TO \'john\'@\'localhost\'' }
+            ]));
+
+            // Mock roles query
+            mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+                { FROM_USER: 'admin_role', FROM_HOST: '%' }
+            ]));
+
+
+            const tool = createSecurityUserPrivilegesTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({
+                user: 'john'
+            }, mockContext) as { users: any[] };
+
+            expect(mockAdapter.executeQuery).toHaveBeenCalledTimes(3);
+            expect(result.users).toHaveLength(1);
+            expect(result.users[0].user).toBe('john');
+            expect(result.users[0].grants).toHaveLength(1);
+            expect(result.users[0].roles).toContain('admin_role@%');
+        });
+    });
+
+    describe('createSecuritySensitiveTablesTool', () => {
+        it('should identify sensitive tables', async () => {
+            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([
+                { tableName: 'users', columnName: 'password_hash', dataType: 'varchar' },
+                { tableName: 'users', columnName: 'email', dataType: 'varchar' },
+                { tableName: 'payments', columnName: 'credit_card', dataType: 'varchar' }
+            ]));
+
+            const tool = createSecuritySensitiveTablesTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({
+                schema: 'test_db'
+            }, mockContext) as { sensitiveTables: any[], totalSensitiveColumns: number };
+
+            expect(mockAdapter.executeQuery).toHaveBeenCalled();
+            expect(result.sensitiveTables).toHaveLength(2); // users, payments
+            expect(result.totalSensitiveColumns).toBe(3);
+            expect(result.sensitiveTables[0].table).toBe('users');
+            expect(result.sensitiveTables[0].sensitiveColumns).toHaveLength(2);
+        });
+    });
+});