@cmd233/mcp-database-server 1.1.6 → 1.2.0

package/dist/src/handlers/toolHandlers.js

@@ -1,7 +1,7 @@
 import { formatErrorResponse } from '../utils/formatUtils.js';
 // 导入所有工具实现
 import { readQuery, writeQuery, exportQuery } from '../tools/queryTools.js';
-import { createTable, alterTable, dropTable, listTables, describeTable } from '../tools/schemaTools.js';
+import { createTable, alterTable, dropTable, listTables, describeTable, listViews, describeView, getViewDefinition } from '../tools/schemaTools.js';
 import { appendInsight, listInsights } from '../tools/insightTools.js';
 /**
  * 处理列出可用工具的请求
@@ -12,109 +12,498 @@ export function handleListTools() {
         tools: [
             {
                 name: "read_query",
-                description: "Execute SELECT queries to read data from the database",
+                title: "Read Query",
+                description: "Execute a SELECT query to read data from the database. " +
+                    "Returns the complete result set with all matching rows and columns. " +
+                    "Only SELECT statements are allowed - use write_query for data modifications. " +
+                    "Supports all database types: SQLite, SQL Server, PostgreSQL, MySQL.",
                 inputSchema: {
                     type: "object",
                     properties: {
-                        query: { type: "string" },
+                        query: {
+                            type: "string",
+                            description: "The SQL SELECT query to execute (e.g., 'SELECT * FROM users WHERE active = 1')"
+                        },
                     },
                     required: ["query"],
                 },
+                outputSchema: {
+                    type: "object",
+                    properties: {
+                        rows: {
+                            type: "array",
+                            description: "Array of result rows from the query"
+                        },
+                        columns: {
+                            type: "array",
+                            description: "Array of column names in the result set"
+                        }
+                    }
+                },
+                annotations: {
+                    readOnlyHint: true,
+                    idempotentHint: true
+                }
             },
             {
                 name: "write_query",
-                description: "Execute INSERT, UPDATE, or DELETE queries",
+                title: "Write Query",
+                description: "Execute INSERT, UPDATE, DELETE, or TRUNCATE queries to modify database data. " +
+                    "Returns the number of affected rows. " +
+                    "Cannot be used for SELECT queries - use read_query instead. " +
+                    "Supports all database types: SQLite, SQL Server, PostgreSQL, MySQL. " +
+                    "Requires confirm=true as a safety measure to prevent accidental data modification.",
                 inputSchema: {
                     type: "object",
                     properties: {
-                        query: { type: "string" },
+                        query: {
+                            type: "string",
+                            description: "The SQL INSERT/UPDATE/DELETE/TRUNCATE query to execute"
+                        },
+                        confirm: {
+                            type: "boolean",
+                            description: "Must be set to true to confirm data modification"
+                        },
                     },
                     required: ["query"],
                 },
+                outputSchema: {
+                    type: "object",
+                    properties: {
+                        affected_rows: {
+                            type: "number",
+                            description: "Number of rows affected by the operation"
+                        },
+                        last_id: {
+                            type: "number",
+                            description: "ID of the last inserted row (for INSERT operations)"
+                        }
+                    }
+                },
+                annotations: {
+                    readOnlyHint: false,
+                    destructiveHint: true
+                }
             },
             {
                 name: "create_table",
-                description: "Create new tables in the database",
+                title: "Create Table",
+                description: "Create a new table in the database using a CREATE TABLE statement. " +
+                    "Supports all standard SQL table creation syntax including column definitions, " +
+                    "constraints, indexes, and relationships. " +
+                    "Works with SQLite, SQL Server, PostgreSQL, and MySQL. " +
+                    "Requires confirm=true as a safety measure to prevent accidental table creation.",
                 inputSchema: {
                     type: "object",
                     properties: {
-                        query: { type: "string" },
+                        query: {
+                            type: "string",
+                            description: "The complete CREATE TABLE SQL statement"
+                        },
+                        confirm: {
+                            type: "boolean",
+                            description: "Must be set to true to confirm table creation"
+                        },
                     },
                     required: ["query"],
                 },
+                outputSchema: {
+                    type: "object",
+                    properties: {
+                        success: {
+                            type: "boolean",
+                            description: "True if the table was created successfully"
+                        },
+                        message: {
+                            type: "string",
+                            description: "Success message with table name"
+                        }
+                    }
+                },
+                annotations: {
+                    readOnlyHint: false,
+                    destructiveHint: true
+                }
             },
             {
                 name: "alter_table",
-                description: "Modify existing table schema (add columns, rename tables, etc.)",
+                title: "Alter Table",
+                description: "Modify an existing table's structure using ALTER TABLE statements. " +
+                    "Supports adding columns, dropping columns, renaming columns, changing data types, " +
+                    "and other table modifications. " +
+                    "The table must exist before alterations can be made. " +
+                    "Requires confirm=true as a safety measure to prevent accidental schema changes.",
                 inputSchema: {
                     type: "object",
                     properties: {
-                        query: { type: "string" },
+                        query: {
+                            type: "string",
+                            description: "The ALTER TABLE SQL statement to modify table structure"
+                        },
+                        confirm: {
+                            type: "boolean",
+                            description: "Must be set to true to confirm table alteration"
+                        },
                     },
                     required: ["query"],
                 },
+                outputSchema: {
+                    type: "object",
+                    properties: {
+                        success: {
+                            type: "boolean",
+                            description: "True if the table was altered successfully"
+                        },
+                        message: {
+                            type: "string",
+                            description: "Success message confirming the alteration"
+                        }
+                    }
+                },
+                annotations: {
+                    readOnlyHint: false,
+                    destructiveHint: true
+                }
             },
             {
                 name: "drop_table",
-                description: "Remove a table from the database with safety confirmation",
+                title: "Drop Table",
+                description: "Permanently delete a table from the database. " +
+                    "This operation cannot be undone - all data and structure will be lost. " +
+                    "Requires confirm=true to execute as a safety measure. " +
+                    "Validates that the table exists before attempting deletion.",
                 inputSchema: {
                     type: "object",
                     properties: {
-                        table_name: { type: "string" },
-                        confirm: { type: "boolean" },
+                        table_name: {
+                            type: "string",
+                            description: "Name of the table to delete"
+                        },
+                        confirm: {
+                            type: "boolean",
+                            description: "Must be set to true to confirm table deletion"
+                        },
                     },
                     required: ["table_name", "confirm"],
                 },
+                outputSchema: {
+                    type: "object",
+                    properties: {
+                        success: {
+                            type: "boolean",
+                            description: "True if the table was dropped successfully"
+                        },
+                        message: {
+                            type: "string",
+                            description: "Success message with the dropped table name"
+                        }
+                    }
+                },
+                annotations: {
+                    readOnlyHint: false,
+                    destructiveHint: true
+                }
             },
             {
                 name: "export_query",
-                description: "Export query results to various formats (CSV, JSON)",
+                title: "Export Query",
+                description: "Execute a SELECT query and export the results in CSV or JSON format. " +
+                    "Only SELECT queries are allowed. " +
+                    "CSV format returns comma-separated values with headers. " +
+                    "JSON format returns the raw result array. " +
+                    "Useful for data analysis, reporting, or data transfer.",
                 inputSchema: {
                     type: "object",
                     properties: {
-                        query: { type: "string" },
-                        format: { type: "string", enum: ["csv", "json"] },
+                        query: {
+                            type: "string",
+                            description: "The SQL SELECT query to execute and export"
+                        },
+                        format: {
+                            type: "string",
+                            enum: ["csv", "json"],
+                            description: "Output format: 'csv' for comma-separated values, 'json' for raw JSON array"
+                        },
                     },
                     required: ["query", "format"],
                 },
+                outputSchema: {
+                    type: "object",
+                    properties: {
+                        data: {
+                            type: "string",
+                            description: "Exported data in the requested format"
+                        },
+                        format: {
+                            type: "string",
+                            description: "The format of the exported data"
+                        }
+                    }
+                },
+                annotations: {
+                    readOnlyHint: true,
+                    idempotentHint: true
+                }
             },
             {
                 name: "list_tables",
-                description: "Get a list of all tables in the database",
+                title: "List Tables",
+                description: "Retrieve a list of all table names in the current database. " +
+                    "Returns only table names without structure details. " +
+                    "Use describe_table to get detailed column information for a specific table. " +
+                    "Set include_views=true to also include database views (SQL Server only).",
                 inputSchema: {
                     type: "object",
-                    properties: {},
+                    properties: {
+                        include_views: {
+                            type: "boolean",
+                            description: "Set to true to include views in the result (SQL Server only)"
+                        },
+                    },
+                },
+                outputSchema: {
+                    type: "object",
+                    properties: {
+                        tables: {
+                            type: "array",
+                            items: {
+                                type: "object",
+                                properties: {
+                                    name: { type: "string", description: "Table or view name" },
+                                    type: { type: "string", enum: ["table", "view"], description: "Object type" }
+                                }
+                            },
+                            description: "Array of table/view names and types in the database"
+                        }
+                    }
                 },
+                annotations: {
+                    readOnlyHint: true,
+                    idempotentHint: true
+                }
             },
             {
                 name: "describe_table",
-                description: "View schema information for a specific table",
+                title: "Describe Table",
+                description: "Get detailed structural information about a specific table or view. " +
+                    "Returns column name, data type, nullable status, default value, " +
+                    "primary key status, and column comment (if supported). " +
+                    "Supports both tables and views (SQL Server only for views). " +
+                    "The table or view must exist in the database.",
                 inputSchema: {
                     type: "object",
                     properties: {
-                        table_name: { type: "string" },
+                        table_name: {
+                            type: "string",
+                            description: "Name of the table or view to describe"
+                        },
                     },
                     required: ["table_name"],
                 },
+                outputSchema: {
+                    type: "object",
+                    properties: {
+                        name: { type: "string", description: "Table or view name" },
+                        type: { type: "string", enum: ["table", "view"], description: "Object type" },
+                        columns: {
+                            type: "array",
+                            description: "Array of column definitions",
+                            items: {
+                                type: "object",
+                                properties: {
+                                    name: { type: "string", description: "Column name" },
+                                    type: { type: "string", description: "Data type" },
+                                    notnull: { type: "boolean", description: "Whether the column is NOT NULL" },
+                                    default_value: { type: "string", description: "Default value" },
+                                    primary_key: { type: "boolean", description: "Whether the column is a primary key" },
+                                    comment: { type: "string", description: "Column comment" }
+                                }
+                            }
+                        }
+                    }
+                },
+                annotations: {
+                    readOnlyHint: true,
+                    idempotentHint: true
+                }
+            },
+            {
+                name: "list_views",
+                title: "List Views",
+                description: "Retrieve a list of all view names in the current database. " +
+                    "Only works with SQL Server databases. " +
+                    "Returns only view names without structure details. " +
+                    "Use describe_view to get detailed column information for a specific view.",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+                outputSchema: {
+                    type: "object",
+                    properties: {
+                        views: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Array of view names in the database"
+                        }
+                    }
+                },
+                annotations: {
+                    readOnlyHint: true,
+                    idempotentHint: true
+                }
+            },
+            {
+                name: "describe_view",
+                title: "Describe View",
+                description: "Get detailed structural information about a specific view. " +
+                    "Only works with SQL Server databases. " +
+                    "Returns column name, data type, nullable status, default value, " +
+                    "primary key status, and column comment (if available). " +
+                    "The view must exist in the database.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        view_name: {
+                            type: "string",
+                            description: "Name of the view to describe"
+                        },
+                    },
+                    required: ["view_name"],
+                },
+                outputSchema: {
+                    type: "object",
+                    properties: {
+                        name: { type: "string", description: "View name" },
+                        type: { type: "string", description: "Always 'view'" },
+                        columns: {
+                            type: "array",
+                            description: "Array of column definitions",
+                            items: {
+                                type: "object",
+                                properties: {
+                                    name: { type: "string", description: "Column name" },
+                                    type: { type: "string", description: "Data type" },
+                                    notnull: { type: "boolean", description: "Whether the column is NOT NULL" },
+                                    default_value: { type: "string", description: "Default value" },
+                                    primary_key: { type: "boolean", description: "Whether the column is a primary key" },
+                                    comment: { type: "string", description: "Column comment" }
+                                }
+                            }
+                        }
+                    }
+                },
+                annotations: {
+                    readOnlyHint: true,
+                    idempotentHint: true
+                }
+            },
+            {
+                name: "get_view_definition",
+                title: "Get View Definition",
+                description: "Retrieve the SQL definition (CREATE VIEW statement) of a specific view. " +
+                    "Only works with SQL Server databases. " +
+                    "Returns the complete CREATE VIEW SQL statement. " +
+                    "Note: Views created WITH ENCRYPTION cannot have their definition retrieved.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        view_name: {
+                            type: "string",
+                            description: "Name of the view to get definition for"
+                        },
+                    },
+                    required: ["view_name"],
+                },
+                outputSchema: {
+                    type: "object",
+                    properties: {
+                        name: { type: "string", description: "View name" },
+                        definition: { type: "string", description: "CREATE VIEW SQL statement" },
+                        message: { type: "string", description: "Additional information if definition is unavailable" }
+                    }
+                },
+                annotations: {
+                    readOnlyHint: true,
+                    idempotentHint: true
+                }
             },
             {
                 name: "append_insight",
-                description: "Add a business insight to the memo",
+                title: "Append Insight",
+                description: "Add a business insight to the SQLite insights memo. " +
+                    "Only works with SQLite databases - creates and uses an mcp_insights table. " +
+                    "Each insight is stored with a timestamp for tracking. " +
+                    "Useful for maintaining notes during analysis sessions. " +
+                    "Requires confirm=true as a safety measure to prevent accidental data insertion.",
                 inputSchema: {
                     type: "object",
                     properties: {
-                        insight: { type: "string" },
+                        insight: {
+                            type: "string",
+                            description: "The business insight text to store in the memo"
+                        },
+                        confirm: {
+                            type: "boolean",
+                            description: "Must be set to true to confirm adding the insight"
+                        },
                     },
                     required: ["insight"],
                 },
+                outputSchema: {
+                    type: "object",
+                    properties: {
+                        success: {
+                            type: "boolean",
+                            description: "True if the insight was added successfully"
+                        },
+                        id: {
+                            type: "number",
+                            description: "ID of the newly created insight entry"
+                        },
+                        message: {
+                            type: "string",
+                            description: "Success message"
+                        }
+                    }
+                },
+                annotations: {
+                    readOnlyHint: false,
+                    destructiveHint: false
+                }
             },
             {
                 name: "list_insights",
-                description: "List all business insights in the memo",
+                title: "List Insights",
+                description: "Retrieve all stored business insights from the SQLite insights memo. " +
+                    "Only works with SQLite databases. " +
+                    "Returns insights in descending order by creation time (newest first). " +
+                    "Returns an empty list if no insights have been stored yet.",
                 inputSchema: {
                     type: "object",
                     properties: {},
                 },
+                outputSchema: {
+                    type: "object",
+                    properties: {
+                        insights: {
+                            type: "array",
+                            description: "Array of insight entries",
+                            items: {
+                                type: "object",
+                                properties: {
+                                    id: { type: "number", description: "Insight ID" },
+                                    insight: { type: "string", description: "Insight text" },
+                                    created_at: { type: "string", description: "Creation timestamp" }
+                                }
+                            }
+                        }
+                    }
+                },
+                annotations: {
+                    readOnlyHint: true,
+                    idempotentHint: true
+                }
             },
         ],
     };
@@ -131,25 +520,31 @@ export async function handleToolCall(name, args) {
             case "read_query":
                 return await readQuery(args.query);
             case "write_query":
-                return await writeQuery(args.query);
+                return await writeQuery(args.query, args.confirm);
             case "create_table":
-                return await createTable(args.query);
+                return await createTable(args.query, args.confirm);
             case "alter_table":
-                return await alterTable(args.query);
+                return await alterTable(args.query, args.confirm);
             case "drop_table":
                 return await dropTable(args.table_name, args.confirm);
             case "export_query":
                 return await exportQuery(args.query, args.format);
             case "list_tables":
-                return await listTables();
+                return await listTables(args.include_views);
             case "describe_table":
                 return await describeTable(args.table_name);
+            case "list_views":
+                return await listViews();
+            case "describe_view":
+                return await describeView(args.view_name);
+            case "get_view_definition":
+                return await getViewDefinition(args.view_name);
             case "append_insight":
-                return await appendInsight(args.insight);
+                return await appendInsight(args.insight, args.confirm);
             case "list_insights":
                 return await listInsights();
             default:
-                throw new Error(`Unknown tool: ${name}`);
+                throw new Error(`未知的工具: ${name}`);
         }
     }
     catch (error) {

package/dist/src/index.js

@@ -27,12 +27,12 @@ const server = new Server({
 // 解析命令行参数
 const args = process.argv.slice(2);
 if (args.length === 0) {
-    logger.error("Please provide database connection information");
-    logger.error("Usage for SQLite: node index.js <database_file_path>");
-    logger.error("Usage for SQL Server: node index.js --sqlserver --server <server> --database <database> [--user <user> --password <password>]");
-    logger.error("Usage for PostgreSQL: node index.js --postgresql --host <host> --database <database> [--user <user> --password <password> --port <port>]");
-    logger.error("Usage for MySQL: node index.js --mysql --host <host> --database <database> [--user <user> --password <password> --port <port>]");
-    logger.error("Usage for MySQL with AWS IAM: node index.js --mysql --aws-iam-auth --host <rds-endpoint> --database <database> --user <aws-username> --aws-region <region>");
+    logger.error("请提供数据库连接信息");
+    logger.error("SQLite 用法: node index.js <database_file_path>");
+    logger.error("SQL Server 用法: node index.js --sqlserver --server <server> --database <database> [--user <user> --password <password>]");
+    logger.error("PostgreSQL 用法: node index.js --postgresql --host <host> --database <database> [--user <user> --password <password> --port <port>]");
+    logger.error("MySQL 用法: node index.js --mysql --host <host> --database <database> [--user <user> --password <password> --port <port>]");
+    logger.error("MySQL with AWS IAM 用法: node index.js --mysql --aws-iam-auth --host <rds-endpoint> --database <database> --user <aws-username> --aws-region <region>");
     process.exit(1);
 }
 // 解析参数以确定数据库类型和连接信息
@@ -67,7 +67,7 @@ if (args.includes('--sqlserver')) {
     }
     // 验证 SQL Server 连接信息
     if (!connectionInfo.server || !connectionInfo.database) {
-        logger.error("Error: SQL Server requires --server and --database parameters");
+        logger.error("错误: SQL Server 需要 --server 和 --database 参数");
         process.exit(1);
     }
 }
@@ -109,7 +109,7 @@ else if (args.includes('--postgresql') || args.includes('--postgres')) {
     }
     // 验证 PostgreSQL 连接信息
     if (!connectionInfo.host || !connectionInfo.database) {
-        logger.error("Error: PostgreSQL requires --host and --database parameters");
+        logger.error("错误: PostgreSQL 需要 --host 和 --database 参数");
         process.exit(1);
     }
 }
@@ -165,22 +165,22 @@ else if (args.includes('--mysql')) {
     }
     // 验证 MySQL 连接信息
     if (!connectionInfo.host || !connectionInfo.database) {
-        logger.error("Error: MySQL requires --host and --database parameters");
+        logger.error("错误: MySQL 需要 --host 和 --database 参数");
         process.exit(1);
     }
     // AWS IAM 认证的额外验证
     if (connectionInfo.awsIamAuth) {
         if (!connectionInfo.user) {
-            logger.error("Error: AWS IAM authentication requires --user parameter");
+            logger.error("错误: AWS IAM 认证需要 --user 参数");
             process.exit(1);
         }
         if (!connectionInfo.awsRegion) {
-            logger.error("Error: AWS IAM authentication requires --aws-region parameter");
+            logger.error("错误: AWS IAM 认证需要 --aws-region 参数");
             process.exit(1);
         }
         // 为 AWS IAM 认证自动启用 SSL (必需)
         connectionInfo.ssl = true;
-        logger.info("AWS IAM authentication enabled - SSL automatically configured");
+        logger.info("AWS IAM 认证已启用 - SSL 已自动配置");
     }
 }
 else {
@@ -204,21 +204,21 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 });
 // 优雅处理关闭信号
 process.on('SIGINT', async () => {
-    logger.info('Shutting down gracefully...');
+    logger.info('正在优雅关闭...');
     await closeDatabase();
     process.exit(0);
 });
 process.on('SIGTERM', async () => {
-    logger.info('Shutting down gracefully...');
+    logger.info('正在优雅关闭...');
     await closeDatabase();
     process.exit(0);
 });
 // 添加全局错误处理器
 process.on('uncaughtException', (error) => {
-    logger.error('Uncaught exception:', error);
+    logger.error('未捕获的异常:', error);
 });
 process.on('unhandledRejection', (reason, promise) => {
-    logger.error('Unhandled Rejection at:', promise, 'reason:', reason);
+    logger.error('未处理的 Promise 拒绝:', promise, '原因:', reason);
 });
 /**
  * 启动服务器
@@ -248,12 +248,12 @@ async function runServer() {
         logger.info('Server running. Press Ctrl+C to exit.');
     }
     catch (error) {
-        logger.error("Failed to initialize:", error);
+        logger.error("初始化失败:", error);
         process.exit(1);
     }
 }
 // 启动服务器
 runServer().catch(error => {
-    logger.error("Server initialization failed:", error);
+    logger.error("服务器初始化失败:", error);
     process.exit(1);
 });