@cmd233/mcp-database-server 1.1.7 → 1.3.0

package/dist/src/tools/insightTools.js

@@ -3,13 +3,21 @@ import { formatSuccessResponse } from '../utils/formatUtils.js';
 /**
  * 添加业务洞察到备忘录
  * @param insight 业务洞察文本
- * @returns 操作结果
+ * @param confirm 安全确认标志（默认 false，防止误操作）
+ * @returns 操作结果，包含新增记录的 ID
  */
-export async function appendInsight(insight) {
+export async function appendInsight(insight, confirm = false) {
     try {
         if (!insight) {
             throw new Error("洞察内容不能为空");
         }
+        // 确认检查：防止误操作
+        if (!confirm) {
+            return formatSuccessResponse({
+                success: false,
+                message: "需要安全确认。设置 confirm=true 以继续添加洞察。"
+            });
+        }
         // 如果 insights 表不存在则创建
         await dbExec(`
       CREATE TABLE IF NOT EXISTS mcp_insights (
@@ -18,9 +26,13 @@ export async function appendInsight(insight) {
         created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
       )
     `);
-        // 插入洞察记录
-        await dbRun("INSERT INTO mcp_insights (insight) VALUES (?)", [insight]);
-        return formatSuccessResponse({ success: true, message: "洞察已添加" });
+        // 插入洞察记录并获取返回的 ID
+        const result = await dbRun("INSERT INTO mcp_insights (insight) VALUES (?)", [insight]);
+        return formatSuccessResponse({
+            success: true,
+            message: "洞察已添加",
+            id: result.lastID
+        });
     }
     catch (error) {
         throw new Error(`添加洞察失败: ${error.message}`);

package/dist/src/tools/queryTools.js

@@ -20,17 +20,29 @@ export async function readQuery(query) {
 /**
  * 执行数据修改 SQL 查询
  * @param query 要执行的 SQL 查询
+ * @param confirm 安全确认标志（默认 false，防止误操作）
  * @returns 受影响行的信息
  */
-export async function writeQuery(query) {
+export async function writeQuery(query, confirm = false) {
     try {
         const lowerQuery = query.trim().toLowerCase();
         if (lowerQuery.startsWith("select")) {
             throw new Error("SELECT 操作请使用 read_query");
         }
-        if (!(lowerQuery.startsWith("insert") || lowerQuery.startsWith("update") || lowerQuery.startsWith("delete"))) {
+        // 支持 INSERT、UPDATE、DELETE 操作
+        // 注意：TRUNCATE 操作已被禁用，因为它不可回滚且不触发触发器
+        const supportedOperations = ["insert", "update", "delete"];
+        const operation = supportedOperations.find(op => lowerQuery.startsWith(op));
+        if (!operation) {
             throw new Error("write_query 只允许执行 INSERT、UPDATE 或 DELETE 操作");
         }
+        // 确认检查：防止误操作
+        if (!confirm) {
+            return formatSuccessResponse({
+                success: false,
+                message: `需要安全确认。设置 confirm=true 以继续执行 ${operation.toUpperCase()} 操作。`
+            });
+        }
         const result = await dbRun(query);
         return formatSuccessResponse({ affected_rows: result.changes });
     }

package/dist/src/tools/schemaTools.js

@@ -1,15 +1,106 @@
-import { dbAll, dbExec, getListTablesQuery, getDescribeTableQuery } from '../db/index.js';
+import { dbAll, dbExec, getListTablesQuery, getDescribeTableQuery, getListViewsQuery, getViewDefinitionQuery, supportsViews, getListProceduresQuery, getDescribeProcedureQuery, getProcedureDefinitionQuery, supportsProcedures } from '../db/index.js';
 import { formatSuccessResponse } from '../utils/formatUtils.js';
+/**
+ * 检查数据库对象是否存在
+ * @param objectName 对象名
+ * @param objectType 对象类型 ('table' | 'view')
+ * @returns 如果存在返回 true，否则返回 false
+ */
+async function checkObjectExists(objectName, objectType) {
+    if (objectType === 'table') {
+        const query = getListTablesQuery();
+        const objects = await dbAll(query);
+        return objects.some(obj => obj.name === objectName);
+    }
+    else if (supportsViews()) {
+        const query = getListViewsQuery();
+        const objects = await dbAll(query);
+        return objects.some(obj => obj.name === objectName);
+    }
+    return false;
+}
+/**
+ * 检查存储过程是否存在
+ * @param procedureName 存储过程名
+ * @returns 如果存在返回 true，否则返回 false
+ */
+async function checkProcedureExists(procedureName) {
+    if (!supportsProcedures()) {
+        return false;
+    }
+    const query = getListProceduresQuery();
+    const procedures = await dbAll(query);
+    return procedures.some(proc => proc.name === procedureName);
+}
+/**
+ * 格式化列结构信息
+ * @param columns 原始列数据数组
+ * @returns 格式化后的列数组
+ */
+function formatColumns(columns) {
+    return columns.map((col) => ({
+        name: col.name,
+        type: col.type,
+        notnull: !!col.notnull,
+        default_value: col.dflt_value,
+        primary_key: !!col.pk,
+        comment: col.comment || null
+    }));
+}
+/**
+ * 从 SQL 语句中提取表名
+ * @param query SQL 语句
+ * @param operation SQL 操作类型（CREATE TABLE、ALTER TABLE 等）
+ * @returns 提取的表名或 null
+ */
+function extractTableName(query, operation) {
+    try {
+        const normalizedQuery = query.trim().replace(/\s+/g, ' ');
+        const operationPrefix = operation.toLowerCase();
+        if (!normalizedQuery.toLowerCase().startsWith(operationPrefix)) {
+            return null;
+        }
+        // 移除操作前缀后的剩余部分
+        const afterOperation = normalizedQuery.substring(operationPrefix.length).trim();
+        // 处理 IF NOT EXISTS 或 IF EXISTS 等子句
+        const patterns = [
+            /^if\s+not\s+exists\s+([^\s(]+)/i, // CREATE TABLE IF NOT EXISTS tablename
+            /^if\s+exists\s+([^\s(]+)/i, // DROP TABLE IF EXISTS tablename
+            /^([^\s(]+)/ // CREATE TABLE tablename
+        ];
+        for (const pattern of patterns) {
+            const match = afterOperation.match(pattern);
+            if (match && match[1]) {
+                // 移除引号（如果有）
+                return match[1].replace(/^[`"[]|[`"\]]$/g, '');
+            }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * 在数据库中创建新表
  * @param query CREATE TABLE SQL 语句
+ * @param confirm 安全确认标志（默认 false，防止误操作）
  * @returns 操作结果
  */
-export async function createTable(query) {
+export async function createTable(query, confirm = false) {
     try {
         if (!query.trim().toLowerCase().startsWith("create table")) {
             throw new Error("只允许执行 CREATE TABLE 语句");
         }
+        // 确认检查：防止误操作
+        if (!confirm) {
+            const tableName = extractTableName(query, "CREATE TABLE");
+            const tableInfo = tableName ? ` '${tableName}'` : '';
+            return formatSuccessResponse({
+                success: false,
+                message: `需要安全确认。设置 confirm=true 以继续创建表${tableInfo}。`
+            });
+        }
         await dbExec(query);
         return formatSuccessResponse({ success: true, message: "表创建成功" });
     }
@@ -20,13 +111,23 @@ export async function createTable(query) {
 /**
  * 修改现有表的结构
  * @param query ALTER TABLE SQL 语句
+ * @param confirm 安全确认标志（默认 false，防止误操作）
  * @returns 操作结果
  */
-export async function alterTable(query) {
+export async function alterTable(query, confirm = false) {
     try {
         if (!query.trim().toLowerCase().startsWith("alter table")) {
             throw new Error("只允许执行 ALTER TABLE 语句");
         }
+        // 确认检查：防止误操作
+        if (!confirm) {
+            const tableName = extractTableName(query, "ALTER TABLE");
+            const tableInfo = tableName ? ` '${tableName}'` : '';
+            return formatSuccessResponse({
+                success: false,
+                message: `需要安全确认。设置 confirm=true 以继续修改表结构${tableInfo}。`
+            });
+        }
         await dbExec(query);
         return formatSuccessResponse({ success: true, message: "表结构修改成功" });
     }
@@ -39,46 +140,33 @@ export async function alterTable(query) {
  * @param tableName 要删除的表名
  * @param confirm 安全确认标志
  * @returns 操作结果
+ * @deprecated DROP 操作已被禁用，此类操作应由 DBA 在数据库层面处理
  */
 export async function dropTable(tableName, confirm) {
-    try {
-        if (!tableName) {
-            throw new Error("表名不能为空");
-        }
-        if (!confirm) {
-            return formatSuccessResponse({
-                success: false,
-                message: "需要安全确认。设置 confirm=true 以继续删除表。"
-            });
-        }
-        // First check if table exists by directly querying for tables
-        const query = getListTablesQuery();
-        const tables = await dbAll(query);
-        const tableNames = tables.map(t => t.name);
-        if (!tableNames.includes(tableName)) {
-            throw new Error(`表 '${tableName}' 不存在`);
-        }
-        // 删除表
-        await dbExec(`DROP TABLE "${tableName}"`);
-        return formatSuccessResponse({
-            success: true,
-            message: `表 '${tableName}' 删除成功`
-        });
-    }
-    catch (error) {
-        throw new Error(`删除表失败: ${error.message}`);
-    }
+    // DROP 操作已被禁用
+    return formatSuccessResponse({
+        success: false,
+        message: "DROP 操作已被禁用，此类操作应由 DBA 在数据库层面处理。如需删除表，请联系数据库管理员。"
+    });
 }
 /**
  * 列出数据库中的所有表
+ * @param includeViews 是否包含视图（默认 false）
  * @returns 表名数组
  */
-export async function listTables() {
+export async function listTables(includeViews = false) {
     try {
         // 使用适配器特定的查询来列出表
         const query = getListTablesQuery();
         const tables = await dbAll(query);
-        return formatSuccessResponse(tables.map((t) => t.name));
+        const result = tables.map((t) => ({ name: t.name, type: 'table' }));
+        // 如果需要包含视图且数据库支持视图
+        if (includeViews && supportsViews()) {
+            const viewsQuery = getListViewsQuery();
+            const views = await dbAll(viewsQuery);
+            result.push(...views.map((v) => ({ name: v.name, type: 'view' })));
+        }
+        return formatSuccessResponse(result);
     }
     catch (error) {
         throw new Error(`列出表失败: ${error.message}`);
@@ -86,34 +174,239 @@ export async function listTables() {
 }
 /**
  * 获取指定表的结构信息
- * @param tableName 要描述的表名
- * @returns 表的列定义
+ * 支持实体表和视图
+ * @param tableName 要描述的表名或视图名
+ * @returns 表/视图的列定义
  */
 export async function describeTable(tableName) {
     try {
         if (!tableName) {
             throw new Error("表名不能为空");
         }
-        // 首先通过直接查询来检查表是否存在
-        const query = getListTablesQuery();
-        const tables = await dbAll(query);
-        const tableNames = tables.map(t => t.name);
-        if (!tableNames.includes(tableName)) {
-            throw new Error(`Table '${tableName}' does not exist`);
+        // 检查是表还是视图
+        let objectType = 'table';
+        if (await checkObjectExists(tableName, 'table')) {
+            objectType = 'table';
+        }
+        else if (supportsViews() && await checkObjectExists(tableName, 'view')) {
+            objectType = 'view';
         }
-        // 使用适配器特定的查询来描述表结构
+        else {
+            // 错误消息不直接包含用户输入，防止日志注入
+            throw new Error(supportsViews() ? "指定的表或视图不存在" : "指定的表不存在");
+        }
+        // 使用适配器特定的查询来描述表/视图结构
         const descQuery = getDescribeTableQuery(tableName);
         const columns = await dbAll(descQuery);
-        return formatSuccessResponse(columns.map((col) => ({
-            name: col.name,
-            type: col.type,
-            notnull: !!col.notnull,
-            default_value: col.dflt_value,
-            primary_key: !!col.pk,
-            comment: col.comment || null
-        })));
+        return formatSuccessResponse({
+            name: tableName,
+            type: objectType,
+            columns: formatColumns(columns)
+        });
     }
     catch (error) {
         throw new Error(`描述表结构失败: ${error.message}`);
     }
 }
+/**
+ * 列出数据库中的所有视图
+ * 仅支持 SQL Server
+ * @returns 视图名数组
+ */
+export async function listViews() {
+    try {
+        if (!supportsViews()) {
+            throw new Error("视图功能仅支持 SQL Server 数据库");
+        }
+        const query = getListViewsQuery();
+        const views = await dbAll(query);
+        return formatSuccessResponse(views.map((v) => v.name));
+    }
+    catch (error) {
+        throw new Error(`列出视图失败: ${error.message}`);
+    }
+}
+/**
+ * 获取指定视图的结构信息
+ * 仅支持 SQL Server
+ * @param viewName 视图名
+ * @returns 视图的列定义
+ */
+export async function describeView(viewName) {
+    try {
+        if (!viewName) {
+            throw new Error("视图名不能为空");
+        }
+        if (!supportsViews()) {
+            throw new Error("视图功能仅支持 SQL Server 数据库");
+        }
+        // 检查视图是否存在
+        if (!(await checkObjectExists(viewName, 'view'))) {
+            // 错误消息不直接包含用户输入，防止日志注入
+            throw new Error("指定的视图不存在");
+        }
+        // 使用相同的 describe 查询获取视图列结构
+        const descQuery = getDescribeTableQuery(viewName);
+        const columns = await dbAll(descQuery);
+        return formatSuccessResponse({
+            name: viewName,
+            type: 'view',
+            columns: formatColumns(columns)
+        });
+    }
+    catch (error) {
+        throw new Error(`描述视图结构失败: ${error.message}`);
+    }
+}
+/**
+ * 获取视图的定义 SQL
+ * 仅支持 SQL Server
+ * 注意: 使用 WITH ENCRYPTION 创建的视图无法获取定义
+ * @param viewName 视图名
+ * @returns 视图定义 SQL
+ */
+export async function getViewDefinition(viewName) {
+    try {
+        if (!viewName) {
+            throw new Error("视图名不能为空");
+        }
+        if (!supportsViews()) {
+            throw new Error("视图功能仅支持 SQL Server 数据库");
+        }
+        // 检查视图是否存在
+        if (!(await checkObjectExists(viewName, 'view'))) {
+            // 错误消息不直接包含用户输入，防止日志注入
+            throw new Error("指定的视图不存在");
+        }
+        // 获取视图定义
+        const defQuery = getViewDefinitionQuery(viewName);
+        const result = await dbAll(defQuery);
+        if (result.length === 0 || !result[0].definition) {
+            return formatSuccessResponse({
+                name: viewName,
+                definition: null,
+                message: "视图定义不可用（可能使用 WITH ENCRYPTION 创建）"
+            });
+        }
+        return formatSuccessResponse({
+            name: viewName,
+            definition: result[0].definition
+        });
+    }
+    catch (error) {
+        throw new Error(`获取视图定义失败: ${error.message}`);
+    }
+}
+/**
+ * 列出数据库中的所有存储过程
+ * 仅支持 SQL Server
+ * @returns 存储过程名数组
+ */
+export async function listProcedures() {
+    try {
+        if (!supportsProcedures()) {
+            throw new Error("存储过程功能仅支持 SQL Server 数据库");
+        }
+        const query = getListProceduresQuery();
+        const procedures = await dbAll(query);
+        return formatSuccessResponse(procedures.map((p) => p.name));
+    }
+    catch (error) {
+        throw new Error(`列出存储过程失败: ${error.message}`);
+    }
+}
+/**
+ * 验证存储过程名称格式是否合法
+ * @param name 存储过程名称
+ * @throws 如果名称包含非法字符
+ */
+function validateProcedureNameFormat(name) {
+    // 检查名称是否为空
+    if (!name || typeof name !== 'string') {
+        throw new Error("存储过程名不能为空");
+    }
+    // 检查名称长度（SQL Server 限制为 128 字符）
+    if (name.length > 128) {
+        throw new Error("存储过程名称长度超过限制（最大 128 字符）");
+    }
+    // 检查是否包含危险的 SQL 字符
+    // 只允许字母、数字、下划线和常见的安全字符
+    const validNamePattern = /^[a-zA-Z_][a-zA-Z0-9_@$#]*$/;
+    if (!validNamePattern.test(name)) {
+        throw new Error("存储过程名称包含非法字符");
+    }
+}
+/**
+ * 验证存储过程操作的前置条件
+ * @param procedureName 存储过程名
+ */
+async function validateProcedureOperation(procedureName) {
+    // 首先验证名称格式，防止恶意输入
+    validateProcedureNameFormat(procedureName);
+    if (!supportsProcedures()) {
+        throw new Error("存储过程功能仅支持 SQL Server 数据库");
+    }
+    if (!(await checkProcedureExists(procedureName))) {
+        // 错误消息不直接包含用户输入，防止日志注入
+        throw new Error("指定的存储过程不存在");
+    }
+}
+/**
+ * 获取存储过程的参数信息
+ * 仅支持 SQL Server
+ * @param procedureName 存储过程名
+ * @returns 存储过程的参数定义
+ */
+export async function describeProcedure(procedureName) {
+    try {
+        await validateProcedureOperation(procedureName);
+        // 获取参数信息
+        const descQuery = getDescribeProcedureQuery(procedureName);
+        const params = await dbAll(descQuery);
+        // 格式化参数信息
+        const parameters = params.map((param) => ({
+            name: param.name,
+            type: param.type,
+            direction: param.direction,
+            default_value: param.default_value,
+            is_output: !!param.is_output
+        }));
+        return formatSuccessResponse({
+            name: procedureName,
+            type: 'procedure',
+            parameters: parameters
+        });
+    }
+    catch (error) {
+        throw new Error(`描述存储过程失败: ${error.message}`);
+    }
+}
+/**
+ * 获取存储过程的定义 SQL
+ * 仅支持 SQL Server
+ * 注意: 使用 WITH ENCRYPTION 创建的存储过程无法获取定义
+ * @param procedureName 存储过程名
+ * @returns 存储过程定义 SQL
+ */
+export async function getProcedureDefinition(procedureName) {
+    try {
+        await validateProcedureOperation(procedureName);
+        // 获取存储过程定义
+        const defQuery = getProcedureDefinitionQuery(procedureName);
+        const result = await dbAll(defQuery);
+        if (result.length === 0 || !result[0].definition) {
+            return formatSuccessResponse({
+                name: procedureName,
+                definition: null,
+                message: "存储过程定义不可用（可能使用 WITH ENCRYPTION 创建）"
+            });
+        }
+        return formatSuccessResponse({
+            name: procedureName,
+            definition: result[0].definition
+        });
+    }
+    catch (error) {
+        throw new Error(`获取存储过程定义失败: ${error.message}`);
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@cmd233/mcp-database-server",
-    "version": "1.1.7",
-    "description": "MCP server for interacting with SQLite, SQL Server, PostgreSQL and MySQL databases (Fixed nullable field detection)",
+    "version": "1.3.0",
+    "description": "MCP server for interacting with SQLite, SQL Server, PostgreSQL and MySQL databases (Added stored procedure support and enhanced SQL injection protection)",
     "license": "MIT",
     "author": "cmd233",
     "homepage": "https://github.com/cmd233/mcp-database-server",
@@ -20,7 +20,6 @@
         "watch": "tsc --watch",
         "start": "node dist/src/index.js",
         "dev": "tsc && node dist/src/index.js",
-        "example": "node examples/example.js",
         "clean": "rimraf dist"
     },
     "dependencies": {