@xingyuchen/mysql-mcp-server 3.0.0

package/dist/log-viewer.js

@@ -0,0 +1,249 @@
+#!/usr/bin/env node
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const logDir = path.join(__dirname, '..', 'logs');
+class LogViewer {
+    /**
+     * 获取所有日志文件
+     */
+    async getLogFiles() {
+        try {
+            const files = await fs.readdir(logDir);
+            return files.filter(file => file.endsWith('.log')).sort();
+        }
+        catch (error) {
+            console.error('无法读取日志目录:', error);
+            return [];
+        }
+    }
+    /**
+     * 读取指定日志文件
+     */
+    async readLogFile(filename) {
+        try {
+            const filePath = path.join(logDir, filename);
+            const content = await fs.readFile(filePath, 'utf-8');
+            const lines = content.split('\n').filter(line => line.trim());
+            return lines.map(line => {
+                try {
+                    // 解析日志行格式: [timestamp] LEVEL: message
+                    const match = line.match(/^\[([^\]]+)\]\s+(\w+):\s+(.+)$/);
+                    if (match) {
+                        const [, timestamp, level, messageWithData] = match;
+                        // 尝试解析JSON数据
+                        let message = messageWithData;
+                        let data = undefined;
+                        try {
+                            const jsonMatch = messageWithData.match(/^(.+?)\s+(\{.+\})$/);
+                            if (jsonMatch) {
+                                message = jsonMatch[1];
+                                data = JSON.parse(jsonMatch[2]);
+                            }
+                        }
+                        catch {
+                            // 如果不是JSON格式，保持原样
+                        }
+                        return { timestamp, level, message, data };
+                    }
+                    return { timestamp: '', level: 'INFO', message: line };
+                }
+                catch {
+                    return { timestamp: '', level: 'INFO', message: line };
+                }
+            });
+        }
+        catch (error) {
+            console.error(`无法读取日志文件 ${filename}:`, error);
+            return [];
+        }
+    }
+    /**
+     * 按级别过滤日志
+     */
+    filterByLevel(logs, level) {
+        return logs.filter(log => log.level.toUpperCase() === level.toUpperCase());
+    }
+    /**
+     * 按时间范围过滤日志
+     */
+    filterByTimeRange(logs, startTime, endTime) {
+        return logs.filter(log => {
+            const logTime = new Date(log.timestamp);
+            const start = new Date(startTime);
+            const end = new Date(endTime);
+            return logTime >= start && logTime <= end;
+        });
+    }
+    /**
+     * 搜索日志内容
+     */
+    searchLogs(logs, keyword) {
+        const lowerKeyword = keyword.toLowerCase();
+        return logs.filter(log => log.message.toLowerCase().includes(lowerKeyword) ||
+            (log.data && JSON.stringify(log.data).toLowerCase().includes(lowerKeyword)));
+    }
+    /**
+     * 格式化输出日志
+     */
+    formatLog(log) {
+        const colorMap = {
+            ERROR: '\x1b[31m', // 红色
+            WARN: '\x1b[33m', // 黄色
+            INFO: '\x1b[36m', // 青色
+            DEBUG: '\x1b[37m', // 白色
+        };
+        const reset = '\x1b[0m';
+        const color = colorMap[log.level] || '';
+        let output = `${color}[${log.timestamp}] ${log.level}${reset}: ${log.message}`;
+        if (log.data) {
+            output += '\n' + JSON.stringify(log.data, null, 2);
+        }
+        return output;
+    }
+    /**
+     * 显示日志统计
+     */
+    showStats(logs) {
+        const stats = logs.reduce((acc, log) => {
+            acc[log.level] = (acc[log.level] || 0) + 1;
+            return acc;
+        }, {});
+        console.log('\n📊 日志统计:');
+        console.log('='.repeat(30));
+        Object.entries(stats).forEach(([level, count]) => {
+            console.log(`${level}: ${count}`);
+        });
+        console.log(`总计: ${logs.length}`);
+    }
+    /**
+     * 获取最近的错误
+     */
+    getRecentErrors(logs, count = 10) {
+        return logs
+            .filter(log => log.level === 'ERROR')
+            .slice(-count)
+            .reverse();
+    }
+    /**
+     * 分析数据库操作
+     */
+    analyzeDatabaseOperations(logs) {
+        const dbOps = logs.filter(log => log.message.includes('SQL操作') ||
+            log.message.includes('数据库连接') ||
+            log.data?.operation);
+        console.log('\n🗄️ 数据库操作分析:');
+        console.log('='.repeat(40));
+        const opStats = dbOps.reduce((acc, log) => {
+            if (log.data?.operation) {
+                acc[log.data.operation] = (acc[log.data.operation] || 0) + 1;
+            }
+            return acc;
+        }, {});
+        Object.entries(opStats).forEach(([op, count]) => {
+            console.log(`${op}: ${count} 次`);
+        });
+        // 显示最近的数据库错误
+        const dbErrors = dbOps.filter(log => log.level === 'ERROR').slice(-5);
+        if (dbErrors.length > 0) {
+            console.log('\n🚨 最近的数据库错误:');
+            dbErrors.forEach(error => {
+                console.log(this.formatLog(error));
+            });
+        }
+    }
+}
+// 命令行接口
+async function main() {
+    const viewer = new LogViewer();
+    const args = process.argv.slice(2);
+    if (args.length === 0) {
+        console.log(`
+MySQL MCP Server 日志查看器
+
+用法:
+  node log-viewer.js list                     # 列出所有日志文件
+  node log-viewer.js view <filename>          # 查看指定日志文件
+  node log-viewer.js errors [filename]        # 查看错误日志
+  node log-viewer.js search <keyword>         # 搜索日志内容
+  node log-viewer.js stats [filename]         # 显示日志统计
+  node log-viewer.js db-analysis [filename]   # 数据库操作分析
+  node log-viewer.js tail [filename] [lines]  # 查看最新日志
+
+示例:
+  node log-viewer.js view combined-2024-01-15.log
+  node log-viewer.js errors
+  node log-viewer.js search "连接失败"
+    `);
+        return;
+    }
+    const command = args[0];
+    switch (command) {
+        case 'list': {
+            const files = await viewer.getLogFiles();
+            console.log('📁 可用的日志文件:');
+            files.forEach(file => console.log(`  ${file}`));
+            break;
+        }
+        case 'view': {
+            const filename = args[1];
+            if (!filename) {
+                console.error('请指定日志文件名');
+                return;
+            }
+            const logs = await viewer.readLogFile(filename);
+            logs.forEach(log => console.log(viewer.formatLog(log)));
+            break;
+        }
+        case 'errors': {
+            const filename = args[1] || 'combined-' + new Date().toISOString().split('T')[0] + '.log';
+            const logs = await viewer.readLogFile(filename);
+            const errors = viewer.filterByLevel(logs, 'ERROR');
+            console.log(`🚨 错误日志 (${errors.length} 条):`);
+            errors.forEach(log => console.log(viewer.formatLog(log)));
+            break;
+        }
+        case 'search': {
+            const keyword = args[1];
+            if (!keyword) {
+                console.error('请指定搜索关键词');
+                return;
+            }
+            const files = await viewer.getLogFiles();
+            const allLogs = [];
+            for (const file of files) {
+                const logs = await viewer.readLogFile(file);
+                allLogs.push(...logs);
+            }
+            const results = viewer.searchLogs(allLogs, keyword);
+            console.log(`🔍 搜索结果 "${keyword}" (${results.length} 条):`);
+            results.forEach(log => console.log(viewer.formatLog(log)));
+            break;
+        }
+        case 'stats': {
+            const filename = args[1] || 'combined-' + new Date().toISOString().split('T')[0] + '.log';
+            const logs = await viewer.readLogFile(filename);
+            viewer.showStats(logs);
+            break;
+        }
+        case 'db-analysis': {
+            const filename = args[1] || 'database-' + new Date().toISOString().split('T')[0] + '.log';
+            const logs = await viewer.readLogFile(filename);
+            viewer.analyzeDatabaseOperations(logs);
+            break;
+        }
+        case 'tail': {
+            const filename = args[1] || 'combined-' + new Date().toISOString().split('T')[0] + '.log';
+            const lines = parseInt(args[2]) || 20;
+            const logs = await viewer.readLogFile(filename);
+            const recent = logs.slice(-lines);
+            console.log(`📋 最新 ${lines} 条日志:`);
+            recent.forEach(log => console.log(viewer.formatLog(log)));
+            break;
+        }
+        default:
+            console.error(`未知命令: ${command}`);
+    }
+}
+main().catch(console.error);

package/dist/logger.js

@@ -0,0 +1,122 @@
+import winston from 'winston';
+import DailyRotateFile from 'winston-daily-rotate-file';
+import path from 'path';
+// 创建日志目录（如果不存在）
+const logDir = 'logs';
+// 定义日志格式
+const logFormat = winston.format.combine(winston.format.timestamp({
+    format: 'YYYY-MM-DD HH:mm:ss'
+}), winston.format.errors({ stack: true }), winston.format.printf(({ timestamp, level, message, stack }) => {
+    return `[${timestamp}] ${level.toUpperCase()}: ${message}${stack ? '\n' + stack : ''}`;
+}));
+// 创建日志传输器
+const transports = [
+    // 控制台输出
+    new winston.transports.Console({
+        format: winston.format.combine(winston.format.colorize(), logFormat),
+        level: 'info'
+    }),
+    // 错误日志文件（按日期轮转）
+    new DailyRotateFile({
+        filename: path.join(logDir, 'error-%DATE%.log'),
+        datePattern: 'YYYY-MM-DD',
+        level: 'error',
+        format: logFormat,
+        maxSize: '20m',
+        maxFiles: '14d',
+        zippedArchive: true
+    }),
+    // 所有日志文件（按日期轮转）
+    new DailyRotateFile({
+        filename: path.join(logDir, 'combined-%DATE%.log'),
+        datePattern: 'YYYY-MM-DD',
+        format: logFormat,
+        maxSize: '20m',
+        maxFiles: '30d',
+        zippedArchive: true
+    }),
+    // 数据库操作专用日志
+    new DailyRotateFile({
+        filename: path.join(logDir, 'database-%DATE%.log'),
+        datePattern: 'YYYY-MM-DD',
+        format: winston.format.combine(logFormat, winston.format.label({ label: 'DATABASE' })),
+        maxSize: '20m',
+        maxFiles: '30d',
+        zippedArchive: true
+    })
+];
+// 创建logger实例
+export const logger = winston.createLogger({
+    level: 'info',
+    format: logFormat,
+    transports,
+    // 处理未捕获的异常
+    exceptionHandlers: [
+        new DailyRotateFile({
+            filename: path.join(logDir, 'exceptions-%DATE%.log'),
+            datePattern: 'YYYY-MM-DD',
+            maxSize: '20m',
+            maxFiles: '14d'
+        })
+    ],
+    // 处理未处理的Promise拒绝
+    rejectionHandlers: [
+        new DailyRotateFile({
+            filename: path.join(logDir, 'rejections-%DATE%.log'),
+            datePattern: 'YYYY-MM-DD',
+            maxSize: '20m',
+            maxFiles: '14d'
+        })
+    ]
+});
+// 数据库专用logger
+export const dbLogger = winston.createLogger({
+    level: 'debug',
+    format: winston.format.combine(winston.format.label({ label: 'DB' }), logFormat),
+    transports: [
+        new winston.transports.Console({
+            format: winston.format.combine(winston.format.colorize(), winston.format.label({ label: 'DB' }), logFormat),
+            level: 'info'
+        }),
+        new DailyRotateFile({
+            filename: path.join(logDir, 'database-%DATE%.log'),
+            datePattern: 'YYYY-MM-DD',
+            maxSize: '20m',
+            maxFiles: '30d'
+        })
+    ]
+});
+// 工具函数：记录SQL操作
+export function logSqlOperation(operation, query, params, duration, error) {
+    const logData = {
+        operation,
+        query: query.replace(/\s+/g, ' ').trim(),
+        params: params ? JSON.stringify(params) : undefined,
+        duration: duration ? `${duration}ms` : undefined,
+        timestamp: new Date().toISOString()
+    };
+    if (error) {
+        dbLogger.error(`SQL操作失败`, { ...logData, error: error.message });
+    }
+    else {
+        dbLogger.info(`SQL操作成功`, logData);
+    }
+}
+// 工具函数：记录连接操作
+export function logConnection(action, config, error) {
+    const logData = {
+        action,
+        host: config?.host,
+        port: config?.port,
+        database: config?.database,
+        user: config?.user,
+        timestamp: new Date().toISOString()
+    };
+    if (error) {
+        dbLogger.error(`数据库${action === 'connect' ? '连接' : '断开'}失败`, { ...logData, error: error.message });
+    }
+    else {
+        dbLogger.info(`数据库${action === 'connect' ? '连接' : '断开'}成功`, logData);
+    }
+}
+export default logger;

package/dist/transaction-manager.js

@@ -0,0 +1,247 @@
+import { dbLogger } from "./logger.js";
+export class TransactionManager {
+    isTransactionActive = false;
+    operationHistory = [];
+    currentTransactionId = null;
+    /**
+     * 检查是否有活跃的事务
+     */
+    isActive() {
+        return this.isTransactionActive;
+    }
+    /**
+     * 获取当前事务ID
+     */
+    getCurrentTransactionId() {
+        return this.currentTransactionId;
+    }
+    /**
+     * 开始新事务
+     */
+    async startTransaction() {
+        const transactionId = `tx_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        this.currentTransactionId = transactionId;
+        this.isTransactionActive = true;
+        this.operationHistory = [];
+        dbLogger.info("自动开始新事务", {
+            transactionId,
+            timestamp: new Date().toISOString()
+        });
+        return transactionId;
+    }
+    /**
+     * 记录操作到历史
+     */
+    recordOperation(operation) {
+        if (!this.isTransactionActive) {
+            throw new Error("没有活跃的事务");
+        }
+        const operationWithId = {
+            ...operation,
+            id: `op_${Date.now()}_${Math.random().toString(36).substr(2, 6)}`,
+            timestamp: new Date()
+        };
+        this.operationHistory.push(operationWithId);
+        dbLogger.info("记录事务操作", {
+            transactionId: this.currentTransactionId,
+            operationId: operationWithId.id,
+            type: operationWithId.type,
+            tableName: operationWithId.tableName,
+            description: operationWithId.description
+        });
+    }
+    /**
+     * 获取操作历史
+     */
+    getOperationHistory() {
+        return [...this.operationHistory];
+    }
+    /**
+     * 获取可回滚的操作列表（格式化显示）
+     */
+    getRollbackOptions() {
+        if (this.operationHistory.length === 0) {
+            return "📝 当前事务中没有任何操作";
+        }
+        let result = "🔄 可回滚的操作历史：\n\n";
+        this.operationHistory.forEach((op, index) => {
+            const timeStr = op.timestamp.toLocaleString('zh-CN');
+            result += `${index + 1}. [${timeStr}] ${op.type} - ${op.description}\n`;
+            result += `   表: ${op.tableName}`;
+            if (op.affectedRows !== undefined) {
+                result += ` | 影响行数: ${op.affectedRows}`;
+            }
+            result += `\n\n`;
+        });
+        result += "💡 提示：\n";
+        result += "- 选择 '提交事务' 将永久保存所有修改\n";
+        result += "- 选择 '回滚到指定步骤' 可以撤销部分操作\n";
+        result += "- 选择 '完全回滚' 将撤销所有操作";
+        return result;
+    }
+    /**
+     * 回滚到指定操作步骤
+     */
+    async rollbackToStep(stepNumber, executeRollback) {
+        if (!this.isTransactionActive) {
+            throw new Error("没有活跃的事务");
+        }
+        if (stepNumber < 1 || stepNumber > this.operationHistory.length) {
+            throw new Error(`无效的步骤号。请选择 1-${this.operationHistory.length} 之间的数字`);
+        }
+        // 获取需要回滚的操作（从最后一个操作开始，回滚到指定步骤）
+        const operationsToRollback = this.operationHistory.slice(stepNumber).reverse();
+        let rollbackCount = 0;
+        const rollbackResults = [];
+        for (const operation of operationsToRollback) {
+            if (operation.rollbackQuery) {
+                try {
+                    await executeRollback(operation.rollbackQuery, operation.rollbackParams);
+                    rollbackCount++;
+                    rollbackResults.push(`✅ 已回滚: ${operation.description}`);
+                    dbLogger.info("执行操作回滚", {
+                        transactionId: this.currentTransactionId,
+                        operationId: operation.id,
+                        rollbackQuery: operation.rollbackQuery
+                    });
+                }
+                catch (error) {
+                    const err = error instanceof Error ? error : new Error(String(error));
+                    rollbackResults.push(`❌ 回滚失败: ${operation.description} - ${err.message}`);
+                    dbLogger.error("操作回滚失败", {
+                        transactionId: this.currentTransactionId,
+                        operationId: operation.id,
+                        error: err.message
+                    });
+                }
+            }
+            else {
+                rollbackResults.push(`⚠️ 无法回滚: ${operation.description} (无回滚查询)`);
+            }
+        }
+        // 更新操作历史，只保留到指定步骤
+        this.operationHistory = this.operationHistory.slice(0, stepNumber);
+        const result = `🔄 回滚操作完成！\n\n` +
+            `📊 回滚统计:\n` +
+            `- 尝试回滚: ${operationsToRollback.length} 个操作\n` +
+            `- 成功回滚: ${rollbackCount} 个操作\n` +
+            `- 剩余操作: ${this.operationHistory.length} 个\n\n` +
+            `📋 回滚详情:\n${rollbackResults.join('\n')}`;
+        return result;
+    }
+    /**
+     * 完全回滚事务
+     */
+    async fullRollback(executeRollback) {
+        if (!this.isTransactionActive) {
+            throw new Error("没有活跃的事务");
+        }
+        const totalOperations = this.operationHistory.length;
+        if (totalOperations === 0) {
+            this.endTransaction();
+            return "📝 当前事务中没有任何操作，事务已结束";
+        }
+        // 执行数据库级别的回滚
+        await executeRollback("ROLLBACK");
+        dbLogger.info("执行完全事务回滚", {
+            transactionId: this.currentTransactionId,
+            operationsCount: totalOperations
+        });
+        this.endTransaction();
+        return `🔄 事务完全回滚成功！\n\n` +
+            `📊 统计信息:\n` +
+            `- 已撤销 ${totalOperations} 个操作\n` +
+            `- 数据库已恢复到事务开始前的状态\n` +
+            `- 事务已结束`;
+    }
+    /**
+     * 提交事务
+     */
+    async commitTransaction(executeCommit) {
+        if (!this.isTransactionActive) {
+            throw new Error("没有活跃的事务");
+        }
+        const totalOperations = this.operationHistory.length;
+        if (totalOperations === 0) {
+            this.endTransaction();
+            return "📝 当前事务中没有任何操作，事务已结束";
+        }
+        // 执行数据库级别的提交
+        await executeCommit();
+        dbLogger.info("提交事务成功", {
+            transactionId: this.currentTransactionId,
+            operationsCount: totalOperations,
+            operations: this.operationHistory.map(op => ({
+                type: op.type,
+                tableName: op.tableName,
+                description: op.description
+            }))
+        });
+        const operationsSummary = this.operationHistory.map((op, index) => `${index + 1}. ${op.type} - ${op.description} (${op.tableName})`).join('\n');
+        this.endTransaction();
+        return `✅ 事务提交成功！所有修改已永久保存到数据库\n\n` +
+            `📊 提交统计:\n` +
+            `- 总操作数: ${totalOperations}\n` +
+            `- 事务ID: ${this.currentTransactionId}\n\n` +
+            `📋 已提交的操作:\n${operationsSummary}`;
+    }
+    /**
+     * 结束事务
+     */
+    endTransaction() {
+        this.isTransactionActive = false;
+        this.operationHistory = [];
+        this.currentTransactionId = null;
+    }
+    /**
+     * 生成回滚查询
+     */
+    generateRollbackQuery(operation) {
+        switch (operation.type) {
+            case 'INSERT':
+                // INSERT的回滚是DELETE
+                if (operation.whereClause) {
+                    return {
+                        query: `DELETE FROM \`${operation.tableName}\` WHERE ${operation.whereClause}`,
+                        params: operation.whereParams
+                    };
+                }
+                return null;
+            case 'UPDATE':
+                // UPDATE的回滚是恢复原始数据
+                if (operation.originalData && operation.whereClause) {
+                    const columns = Object.keys(operation.originalData);
+                    const setClause = columns.map(col => `\`${col}\` = ?`).join(', ');
+                    const values = Object.values(operation.originalData);
+                    return {
+                        query: `UPDATE \`${operation.tableName}\` SET ${setClause} WHERE ${operation.whereClause}`,
+                        params: [...values, ...operation.whereParams || []]
+                    };
+                }
+                return null;
+            case 'DELETE':
+                // DELETE的回滚是INSERT原始数据
+                if (operation.originalData) {
+                    const columns = Object.keys(operation.originalData);
+                    const placeholders = columns.map(() => '?').join(', ');
+                    const values = Object.values(operation.originalData);
+                    return {
+                        query: `INSERT INTO \`${operation.tableName}\` (\`${columns.join('`, `')}\`) VALUES (${placeholders})`,
+                        params: values
+                    };
+                }
+                return null;
+            case 'DROP_TABLE':
+                // DROP TABLE的回滚需要重新创建表（这个比较复杂，暂时不支持）
+                return null;
+            case 'CREATE_TABLE':
+                // CREATE TABLE的回滚是DROP TABLE
+                return {
+                    query: `DROP TABLE \`${operation.tableName}\``,
+                    params: []
+                };
+            default:
+                return null;
+        }
+    }
+}

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "@xingyuchen/mysql-mcp-server",
+  "version": "3.0.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "guangxiang-mysql-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist/**/*",
+    "README.md",
+    "README_ENHANCED.md",
+    "SMITHERY_DEPLOY.md",
+    "smithery.yaml"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "ts-node --esm src/index.ts",
+    "start": "node dist/index.js",
+    "start-gateway": "npm run build && npx supergateway --stdio \"node dist/index.js\" --port 3101",
+    "install-global": "npm run build && npm install -g .",
+    "quick-setup": "npm install && npm run build && echo \"✅ 安装完成！请查看 README.md 了解配置方法\"",
+    "prepublishOnly": "npm run build",
+    "logs": "npm run build && node dist/log-viewer.js",
+    "logs:errors": "npm run build && node dist/log-viewer.js errors",
+    "logs:stats": "npm run build && node dist/log-viewer.js stats",
+    "logs:db": "npm run build && node dist/log-viewer.js db-analysis",
+    "logs:tail": "npm run build && node dist/log-viewer.js tail",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "mcp",
+    "mysql",
+    "database",
+    "model-context-protocol",
+    "ai-assistant",
+    "vscode",
+    "cline",
+    "sql",
+    "crud",
+    "transaction"
+  ],
+  "author": {
+    "name": "guangxiangdebizi",
+    "url": "https://github.com/guangxiangdebizi"
+  },
+  "license": "MIT",
+  "description": "功能强大的MySQL数据库MCP服务器，支持多数据库连接、完整CRUD操作、智能事务管理和回滚功能，专为AI助手设计",
+  "homepage": "https://github.com/guangxiangdebizi/MySQL_MCP#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/guangxiangdebizi/MySQL_MCP.git"
+  },
+  "bugs": {
+    "url": "https://github.com/guangxiangdebizi/MySQL_MCP/issues"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "mysql2": "^3.6.5",
+    "winston": "^3.13.0",
+    "winston-daily-rotate-file": "^5.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.21",
+    "supergateway": "^2.8.3",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.3"
+  }
+}