@cmd233/mcp-database-server 1.1.6 → 1.2.0

package/dist/src/tools/insightTools.js

@@ -3,12 +3,20 @@ 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("Insight text is required");
+            throw new Error("洞察内容不能为空");
+        }
+        // 确认检查：防止误操作
+        if (!confirm) {
+            return formatSuccessResponse({
+                success: false,
+                message: "需要安全确认。设置 confirm=true 以继续添加洞察。"
+            });
         }
         // 如果 insights 表不存在则创建
         await dbExec(`
@@ -18,12 +26,16 @@ 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: "Insight added" });
+        // 插入洞察记录并获取返回的 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 adding insight: ${error.message}`);
+        throw new Error(`添加洞察失败: ${error.message}`);
     }
 }
 /**
@@ -49,6 +61,6 @@ export async function listInsights() {
         return formatSuccessResponse(insights);
     }
     catch (error) {
-        throw new Error(`Error listing insights: ${error.message}`);
+        throw new Error(`列出洞察失败: ${error.message}`);
     }
 }

package/dist/src/tools/queryTools.js

@@ -8,34 +8,45 @@ import { formatSuccessResponse, convertToCSV } from '../utils/formatUtils.js';
 export async function readQuery(query) {
     try {
         if (!query.trim().toLowerCase().startsWith("select")) {
-            throw new Error("Only SELECT queries are allowed with read_query");
+            throw new Error("read_query 只允许执行 SELECT 查询");
         }
         const result = await dbAll(query);
         return formatSuccessResponse(result);
     }
     catch (error) {
-        throw new Error(`SQL Error: ${error.message}`);
+        throw new Error(`SQL 错误: ${error.message}`);
     }
 }
 /**
  * 执行数据修改 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("Use read_query for SELECT operations");
+            throw new Error("SELECT 操作请使用 read_query");
         }
-        if (!(lowerQuery.startsWith("insert") || lowerQuery.startsWith("update") || lowerQuery.startsWith("delete"))) {
-            throw new Error("Only INSERT, UPDATE, or DELETE operations are allowed with write_query");
+        // 支持 INSERT、UPDATE、DELETE 和 TRUNCATE 操作
+        const supportedOperations = ["insert", "update", "delete", "truncate"];
+        const operation = supportedOperations.find(op => lowerQuery.startsWith(op));
+        if (!operation) {
+            throw new Error("write_query 只允许执行 INSERT、UPDATE、DELETE 或 TRUNCATE 操作");
+        }
+        // 确认检查：防止误操作
+        if (!confirm) {
+            return formatSuccessResponse({
+                success: false,
+                message: `需要安全确认。设置 confirm=true 以继续执行 ${operation.toUpperCase()} 操作。`
+            });
         }
         const result = await dbRun(query);
         return formatSuccessResponse({ affected_rows: result.changes });
     }
     catch (error) {
-        throw new Error(`SQL Error: ${error.message}`);
+        throw new Error(`SQL 错误: ${error.message}`);
     }
 }
 /**
@@ -47,7 +58,7 @@ export async function writeQuery(query) {
 export async function exportQuery(query, format) {
     try {
         if (!query.trim().toLowerCase().startsWith("select")) {
-            throw new Error("Only SELECT queries are allowed with export_query");
+            throw new Error("export_query 只允许执行 SELECT 查询");
         }
         const result = await dbAll(query);
         if (format === "csv") {
@@ -64,10 +75,10 @@ export async function exportQuery(query, format) {
             return formatSuccessResponse(result);
         }
         else {
-            throw new Error("Unsupported export format. Use 'csv' or 'json'");
+            throw new Error("不支持的导出格式。请使用 'csv' 或 'json'");
         }
     }
     catch (error) {
-        throw new Error(`Export Error: ${error.message}`);
+        throw new Error(`导出错误: ${error.message}`);
     }
 }

package/dist/src/tools/schemaTools.js

@@ -1,37 +1,125 @@
-import { dbAll, dbExec, getListTablesQuery, getDescribeTableQuery } from '../db/index.js';
+import { dbAll, dbExec, getListTablesQuery, getDescribeTableQuery, getListViewsQuery, getViewDefinitionQuery, supportsViews } 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 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("Only CREATE TABLE statements are allowed");
+            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: "Table created successfully" });
+        return formatSuccessResponse({ success: true, message: "表创建成功" });
     }
     catch (error) {
-        throw new Error(`SQL Error: ${error.message}`);
+        throw new Error(`SQL 错误: ${error.message}`);
     }
 }
 /**
  * 修改现有表的结构
  * @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("Only ALTER TABLE statements are allowed");
+            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: "Table altered successfully" });
+        return formatSuccessResponse({ success: true, message: "表结构修改成功" });
     }
     catch (error) {
-        throw new Error(`SQL Error: ${error.message}`);
+        throw new Error(`SQL 错误: ${error.message}`);
     }
 }
 /**
@@ -43,77 +131,171 @@ export async function alterTable(query) {
 export async function dropTable(tableName, confirm) {
     try {
         if (!tableName) {
-            throw new Error("Table name is required");
+            throw new Error("表名不能为空");
         }
         if (!confirm) {
             return formatSuccessResponse({
                 success: false,
-                message: "Safety confirmation required. Set confirm=true to proceed with dropping the table."
+                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(`Table '${tableName}' does not exist`);
+        // 检查表是否存在
+        if (!(await checkObjectExists(tableName, 'table'))) {
+            throw new Error(`表 '${tableName}' 不存在`);
         }
-        // Drop the table
+        // 删除表
         await dbExec(`DROP TABLE "${tableName}"`);
         return formatSuccessResponse({
             success: true,
-            message: `Table '${tableName}' dropped successfully`
+            message: `表 '${tableName}' 删除成功`
         });
     }
     catch (error) {
-        throw new Error(`Error dropping table: ${error.message}`);
+        throw new Error(`删除表失败: ${error.message}`);
     }
 }
 /**
  * 列出数据库中的所有表
+ * @param includeViews 是否包含视图（默认 false）
  * @returns 表名数组
  */
-export async function listTables() {
+export async function listTables(includeViews = false) {
     try {
-        // Use adapter-specific query for listing tables
+        // 使用适配器特定的查询来列出表
         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 listing tables: ${error.message}`);
+        throw new Error(`列出表失败: ${error.message}`);
     }
 }
 /**
  * 获取指定表的结构信息
- * @param tableName 要描述的表名
- * @returns 表的列定义
+ * 支持实体表和视图
+ * @param tableName 要描述的表名或视图名
+ * @returns 表/视图的列定义
  */
 export async function describeTable(tableName) {
     try {
         if (!tableName) {
-            throw new Error("Table name is required");
+            throw new Error("表名不能为空");
         }
-        // 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(`Table '${tableName}' does not exist`);
+        // 检查是表还是视图
+        let objectType = 'table';
+        if (await checkObjectExists(tableName, 'table')) {
+            objectType = 'table';
         }
-        // Use adapter-specific query for describing tables
+        else if (supportsViews() && await checkObjectExists(tableName, 'view')) {
+            objectType = 'view';
+        }
+        else {
+            throw new Error(supportsViews() ? `表或视图 '${tableName}' 不存在` : `表 '${tableName}' 不存在`);
+        }
+        // 使用适配器特定的查询来描述表/视图结构
         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(`视图 '${viewName}' 不存在`);
+        }
+        // 使用相同的 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(`视图 '${viewName}' 不存在`);
+        }
+        // 获取视图定义
+        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 describing table: ${error.message}`);
+        throw new Error(`获取视图定义失败: ${error.message}`);
     }
 }

package/dist/src/utils/cryptoUtils.js

@@ -0,0 +1,119 @@
+/**
+ * 加密和确认码工具模块
+ * 用于两步确认机制，防止 AI 模型自动执行危险操作
+ */
+// 硬编码密钥，用于生成确认码
+const CONFIRM_SECRET_KEY = 'mcp-db-server-confirm-key-v1';
+/**
+ * 获取当前分钟时间戳
+ * @returns 当前分钟的时间戳字符串
+ */
+function getMinuteTimestamp() {
+    const now = Date.now();
+    // 转换为分钟级时间戳（去掉秒和毫秒）
+    const minuteTimestamp = Math.floor(now / 60000);
+    return minuteTimestamp.toString();
+}
+/**
+ * 生成简单哈希
+ * 使用简单的字符串哈希算法生成固定长度的哈希值
+ * @param content 要哈希的内容
+ * @returns 8位十六进制哈希字符串
+ */
+function generateSimpleHash(content) {
+    let hash = 0;
+    // 使用简单的字符串哈希算法
+    for (let i = 0; i < content.length; i++) {
+        const char = content.charCodeAt(i);
+        hash = ((hash << 5) - hash) + char;
+        hash = hash & hash; // 转换为 32 位整数
+    }
+    // 转换为无符号整数并转为十六进制，取前 8 位
+    const hashStr = Math.abs(hash).toString(16).padStart(8, '0');
+    return hashStr.substring(0, 8);
+}
+/**
+ * 标准化操作内容
+ * 移除多余的空格，统一大小写，确保相同操作生成相同的确认码
+ * @param query 原始 SQL 查询或操作内容
+ * @returns 标准化后的操作内容
+ */
+export function normalizeOperationContent(query) {
+    // 移除前后空格，将多个连续空格替换为单个空格
+    return query.trim().replace(/\s+/g, ' ');
+}
+/**
+ * 生成确认码
+ * 基于操作内容和当前分钟时间戳生成 8 位十六进制确认码
+ * @param operationContent 操作内容（SQL 查询或操作描述）
+ * @returns 8 位十六进制确认码
+ */
+export function generateConfirmCode(operationContent) {
+    const normalized = normalizeOperationContent(operationContent);
+    const minuteTimestamp = getMinuteTimestamp();
+    const hashInput = normalized + minuteTimestamp + CONFIRM_SECRET_KEY;
+    return generateSimpleHash(hashInput);
+}
+/**
+ * 验证确认码
+ * 验证确认码是否有效，支持当前分钟和上一分钟的确认码（2 分钟窗口）
+ * @param operationContent 操作内容（SQL 查询或操作描述）
+ * @param confirmCode 要验证的确认码
+ * @returns 确认码是否有效
+ */
+export function verifyConfirmCode(operationContent, confirmCode) {
+    if (!confirmCode || confirmCode.length !== 8) {
+        return false;
+    }
+    const normalized = normalizeOperationContent(operationContent);
+    const now = Date.now();
+    const currentMinute = Math.floor(now / 60000);
+    const previousMinute = currentMinute - 1;
+    // 验证当前分钟的确认码
+    const currentHashInput = normalized + currentMinute.toString() + CONFIRM_SECRET_KEY;
+    const currentCode = generateSimpleHash(currentHashInput);
+    if (currentCode === confirmCode) {
+        return true;
+    }
+    // 验证上一分钟的确认码
+    const previousHashInput = normalized + previousMinute.toString() + CONFIRM_SECRET_KEY;
+    const previousCode = generateSimpleHash(previousHashInput);
+    return previousCode === confirmCode;
+}
+/**
+ * 格式化预览响应
+ * 生成预览模式的响应格式，包含确认码和操作说明
+ * @param toolName 工具名称
+ * @param operationContent 操作内容
+ * @param additionalInfo 额外信息（如警告消息）
+ * @returns 预览响应对象
+ */
+export function formatPreviewResponse(toolName, operationContent, additionalInfo) {
+    const confirmCode = generateConfirmCode(operationContent);
+    const response = {
+        preview: true,
+        tool_name: toolName,
+        confirm_code: confirmCode,
+        message: "⚠️ 预览模式：此操作需要确认",
+        operation_content: normalizeOperationContent(operationContent),
+        instructions: [
+            "请仔细检查上述操作内容",
+            "如确认执行，请重新调用此工具并提供确认码",
+            `参数示例: { "preview": false, "confirm_code": "${confirmCode}" }`
+        ]
+    };
+    // 添加额外信息
+    if (additionalInfo?.warning) {
+        response.warning = additionalInfo.warning;
+    }
+    if (additionalInfo?.operation) {
+        response.operation = additionalInfo.operation;
+    }
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify(response, null, 2)
+            }],
+        isError: false
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cmd233/mcp-database-server",
-    "version": "1.1.6",
+    "version": "1.2.0",
     "description": "MCP server for interacting with SQLite, SQL Server, PostgreSQL and MySQL databases (Fixed nullable field detection)",
     "license": "MIT",
     "author": "cmd233",