chaimi-keep-mcp 3.1.44 → 3.1.45-beta.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chaimi-keep-mcp",
-  "version": "3.1.44",
+  "version": "3.1.45-beta.1",
   "description": "柴米记账 MCP Server - 支持 Claude、Cursor、OpenClaw、WorkBuddy 等 AI 工具直接记账",
   "main": "server.js",
   "bin": {
@@ -8,6 +8,7 @@
   },
   "files": [
     "bin/",
+    "utils/",
     "server.js",
     "oauth.js",
     "SKILL.md",

package/server.js

@@ -5,11 +5,27 @@
  * 支持 Claude Desktop、Cursor、WorkBuddy、OpenClaw
  */
 
-// 加载 .env 文件
+// 加载环境变量 - 根据 NODE_ENV 自动选择配置文件
+const NODE_ENV = process.env.NODE_ENV || 'development';
+const envFile = `.env.${NODE_ENV}`;
+
 try {
-  require('dotenv').config();
+  const dotenv = require('dotenv');
+  const fs = require('fs');
+  const path = require('path');
+
+  const envPath = path.join(__dirname, envFile);
+
+  if (fs.existsSync(envPath)) {
+    dotenv.config({ path: envPath });
+    console.log(`✅ 已加载 ${NODE_ENV} 环境配置`);
+  } else {
+    console.warn(`⚠️  警告：${envFile} 文件不存在，请运行 setup.js 生成配置`);
+    // 尝试加载默认 .env 文件
+    dotenv.config();
+  }
 } catch (e) {
-  // dotenv 未安装，忽略
+  console.warn('⚠️  警告：dotenv 未安装或加载失败');
 }
 
 const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
@@ -30,11 +46,106 @@ const MCP_VERSION = packageJson.version;
 // 导入 OAuth 模块
 const { OAuthManager, FileTokenStorage } = require('./oauth.js');
 
+// 导入工具函数
+const { validateDate } = require('./utils/validators.js');
+
+// ==================== 密钥管理 ====================
+
+// Token 加密密钥文件路径
+const SECRET_KEY_FILE = path.join(__dirname, '.mcp-secret-key');
+
+// 自动生成或加载 Token 加密密钥
+function getOrCreateSecretKey() {
+  // 1. 优先使用环境变量（高级用户可以手动配置）
+  if (process.env.MCP_SECRET_KEY) {
+    console.error('✅ 使用环境变量中的 Token 加密密钥');
+    return process.env.MCP_SECRET_KEY;
+  }
+
+  // 2. 尝试从文件加载
+  if (fs.existsSync(SECRET_KEY_FILE)) {
+    const key = fs.readFileSync(SECRET_KEY_FILE, 'utf8').trim();
+    console.error('✅ 从本地文件加载 Token 加密密钥');
+    return key;
+  }
+
+  // 3. 自动生成新密钥（64 字符，256 位）
+  const newKey = crypto.randomBytes(32).toString('hex');
+  fs.writeFileSync(SECRET_KEY_FILE, newKey, { mode: 0o600 }); // 只有当前用户可读写
+  console.error('✅ 已自动生成 Token 加密密钥，保存在 .mcp-secret-key 文件中');
+  console.error('⚠️  请勿删除此文件，否则已授权的 Token 将无法解密');
+  return newKey;
+}
+
+// Token 加密密钥（自动生成或加载）
+const SECRET_KEY = getOrCreateSecretKey();
+
 // API 签名密钥（用于验证请求来自合法 MCP Server）
-const CHAIMI_API_SECRET = 'chaimi-mcp-secret-2024';
+const CHAIMI_API_SECRET = process.env.CHAIMI_API_SECRET;
 
 // URL 加密密钥
-const URL_ENCRYPT_KEY = 'chaimi-url-key-2024';
+const URL_ENCRYPT_KEY = process.env.URL_ENCRYPT_KEY;
+
+// 验证必需的环境变量
+if (!CHAIMI_API_SECRET || !URL_ENCRYPT_KEY) {
+  console.error('❌ 错误：缺少必需的环境变量');
+  console.error('   请运行以下命令生成配置：');
+  console.error('   node setup.js');
+  console.error('');
+  console.error('   然后使用以下命令启动：');
+  console.error('   NODE_ENV=development node server.js  # 开发环境');
+  console.error('   NODE_ENV=production node server.js   # 生产环境');
+  process.exit(1);
+}
+
+// ==================== 加密/解密函数 ====================
+
+// AES-256-GCM 加密（用于 Token）
+function encrypt(text, secretKey) {
+  const iv = crypto.randomBytes(16); // 随机初始化向量
+  const cipher = crypto.createCipheriv(
+    'aes-256-gcm',
+    Buffer.from(secretKey, 'hex'),
+    iv
+  );
+
+  let encrypted = cipher.update(text, 'utf8', 'hex');
+  encrypted += cipher.final('hex');
+
+  const authTag = cipher.getAuthTag(); // 认证标签（防篡改）
+
+  // 返回格式：iv:authTag:encrypted
+  return `${iv.toString('hex')}:${authTag.toString('hex')}:${encrypted}`;
+}
+
+// AES-256-GCM 解密（用于 Token）
+function decrypt(encryptedText, secretKey) {
+  const [ivHex, authTagHex, encrypted] = encryptedText.split(':');
+
+  const decipher = crypto.createDecipheriv(
+    'aes-256-gcm',
+    Buffer.from(secretKey, 'hex'),
+    Buffer.from(ivHex, 'hex')
+  );
+
+  decipher.setAuthTag(Buffer.from(authTagHex, 'hex'));
+
+  let decrypted = decipher.update(encrypted, 'hex', 'utf8');
+  decrypted += decipher.final('utf8');
+
+  return decrypted;
+}
+
+// 旧版 XOR 解密（向后兼容）
+function decryptOldXOR(encrypted, key) {
+  const hex = encrypted.replace('enc:v1:', '');
+  let result = '';
+  for (let i = 0; i < hex.length; i += 2) {
+    const byte = parseInt(hex.substr(i, 2), 16);
+    result += String.fromCharCode(byte ^ key.charCodeAt((i / 2) % key.length));
+  }
+  return result;
+}
 
 // 加密的云函数 URL
 const ENCRYPTED_URLS = {
@@ -43,15 +154,30 @@ const ENCRYPTED_URLS = {
   prompt: 'enc:v1:0b1c15191e53025a1100421e0148000057545156020903080f1d431054180f484819030203035158595043085d5801044c0502114c5b1e53441346150a01065811100d5e0e4b1a425f1f5f5713381306001959'
 };
 
-// 解密 URL 函数
+// 解密 URL 函数（兼容新旧版本）
 function decryptUrl(encrypted, key) {
-  const hex = encrypted.replace('enc:v1:', '');
-  let result = '';
-  for (let i = 0; i < hex.length; i += 2) {
-    const byte = parseInt(hex.substr(i, 2), 16);
-    result += String.fromCharCode(byte ^ key.charCodeAt((i / 2) % key.length));
+  // 新版本（AES-256-GCM）
+  if (encrypted.startsWith('enc:v2:')) {
+    const parts = encrypted.replace('enc:v2:', '').split(':');
+    const iv = Buffer.from(parts[0], 'hex');
+    const authTag = Buffer.from(parts[1], 'hex');
+    const ciphertext = parts[2];
+
+    const keyBuffer = crypto.scryptSync(key, 'salt', 32);
+    const decipher = crypto.createDecipheriv('aes-256-gcm', keyBuffer, iv);
+    decipher.setAuthTag(authTag);
+
+    let decrypted = decipher.update(ciphertext, 'hex', 'utf8');
+    decrypted += decipher.final('utf8');
+    return decrypted;
   }
-  return result;
+
+  // 旧版本（XOR）- 向后兼容
+  if (encrypted.startsWith('enc:v1:')) {
+    return decryptOldXOR(encrypted, key);
+  }
+
+  throw new Error('不支持的加密格式');
 }
 
 // 配置 - 微信云函数（运行时解密）
@@ -59,8 +185,8 @@ const MCP_HUB_URL = process.env.MCP_HUB_URL || decryptUrl(ENCRYPTED_URLS.hub, UR
 const MCP_PROMPT_URL = process.env.MCP_PROMPT_URL || decryptUrl(ENCRYPTED_URLS.prompt, URL_ENCRYPT_KEY);
 const MCP_OAUTH_URL = process.env.MCP_OAUTH_URL || decryptUrl(ENCRYPTED_URLS.oauth, URL_ENCRYPT_KEY);
 
-// Token 缓存
-let cachedToken = null;
+// Token 缓存（加密存储）
+let cachedEncryptedToken = null;
 let tokenExpireTime = 0;
 
 // OAuth 管理器实例
@@ -108,8 +234,8 @@ async function initOAuthManager() {
       // 检查 Token 是否过期（预留5分钟缓冲）
       const expiresAt = new Date(existingToken.expiresAt).getTime();
       if (expiresAt > Date.now() + 5 * 60 * 1000) {
-        // Token 有效，设置授权状态
-        cachedToken = existingToken.accessToken;
+        // Token 有效，加密后缓存
+        cachedEncryptedToken = encrypt(existingToken.accessToken, SECRET_KEY);
         tokenExpireTime = expiresAt;
         authState.isAuthorized = true;
         console.error('✅ 已从文件加载有效 Token，无需重新授权');
@@ -371,15 +497,103 @@ const toolMapping = {
   'export_data': 'exportData',
 };
 
+// ==================== 请求频率限制 ====================
+
+// 限流配置
+const RATE_LIMITS = {
+  // 记账工具：1 分钟 10 次
+  write: {
+    tools: ['save_expense', 'save_receipt', 'save_income'],
+    maxRequests: 10,
+    windowMs: 60 * 1000, // 1 分钟
+  },
+  // 查询工具：1 天 10 次
+  read: {
+    tools: ['get_expenses', 'get_receipt_list', 'get_statistics', 'get_insights', 'export_data'],
+    maxRequests: 10,
+    windowMs: 24 * 60 * 60 * 1000, // 1 天
+  },
+  // 配置读取工具：1 分钟 10 次
+  config: {
+    tools: ['get_skill', 'get_parse_prompt', 'get_text_parse_prompt'],
+    maxRequests: 10,
+    windowMs: 60 * 1000, // 1 分钟
+  },
+  // 反馈提交：1 天 5 次
+  feedback: {
+    tools: ['submit_feedback'],
+    maxRequests: 5,
+    windowMs: 24 * 60 * 60 * 1000, // 1 天
+  },
+};
+
+// 限流记录：{ toolName: [timestamp1, timestamp2, ...] }
+const rateLimitRecords = {};
+
+// 检查是否超过频率限制
+function checkRateLimit(toolName) {
+  // 查找工具所属的限流组
+  let limitConfig = null;
+  let limitType = null;
+
+  for (const [type, config] of Object.entries(RATE_LIMITS)) {
+    if (config.tools.includes(toolName)) {
+      limitConfig = config;
+      limitType = type;
+      break;
+    }
+  }
+
+  // 如果工具不在限流列表中，直接通过
+  if (!limitConfig) {
+    return { allowed: true };
+  }
+
+  const now = Date.now();
+  const windowStart = now - limitConfig.windowMs;
+
+  // 初始化记录
+  if (!rateLimitRecords[toolName]) {
+    rateLimitRecords[toolName] = [];
+  }
+
+  // 清理过期记录
+  rateLimitRecords[toolName] = rateLimitRecords[toolName].filter(
+    timestamp => timestamp > windowStart
+  );
+
+  // 检查是否超过限制
+  if (rateLimitRecords[toolName].length >= limitConfig.maxRequests) {
+    const oldestRequest = rateLimitRecords[toolName][0];
+    const resetTime = oldestRequest + limitConfig.windowMs;
+    const waitSeconds = Math.ceil((resetTime - now) / 1000);
+
+    return {
+      allowed: false,
+      limitType,
+      maxRequests: limitConfig.maxRequests,
+      windowMs: limitConfig.windowMs,
+      resetTime,
+      waitSeconds,
+    };
+  }
+
+  // 记录本次请求
+  rateLimitRecords[toolName].push(now);
+
+  return { allowed: true };
+}
+
 // 获取或刷新 Token（OAuth 2.0 Device Flow）
 const TOKEN_REFRESH_INTERVAL = 2 * 60 * 60 * 1000;
 let lastRefreshTime = 0;
 
 async function getToken() {
   // 步骤1：检查内存缓存 Token（最快路径）
-  if (cachedToken && tokenExpireTime > Date.now() + 5 * 60 * 1000) {
+  if (cachedEncryptedToken && tokenExpireTime > Date.now() + 5 * 60 * 1000) {
     if (Date.now() - lastRefreshTime < TOKEN_REFRESH_INTERVAL) {
-      return cachedToken;
+      // 解密后返回
+      return decrypt(cachedEncryptedToken, SECRET_KEY);
     }
   }
 
@@ -390,12 +604,14 @@ async function getToken() {
   // 步骤2：尝试从文件加载并刷新 Token
   try {
     const oauthToken = await oauthManager.getValidToken();
-    cachedToken = oauthToken.accessToken;
+    // 加密后缓存
+    cachedEncryptedToken = encrypt(oauthToken.accessToken, SECRET_KEY);
     tokenExpireTime = oauthToken.expiresAt;
     lastRefreshTime = Date.now();
     authState.isAuthorized = true;
     await oauthManager.clearAuthState();
-    return cachedToken;
+    // 解密后返回
+    return decrypt(cachedEncryptedToken, SECRET_KEY);
   } catch (err) {
     // Token 无效，需要重新授权
     console.error('⏰ Token 无效，需要重新授权:', err.message);
@@ -666,7 +882,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
   const startTime = Date.now();
   const traceId = generateTraceId();
   const osInfo = getOSInfo();
-  
+
   // 提取元数据字段
   const agentType = args.agentType || process.env.AGENT_TYPE || process.env.MCP_AGENT_TYPE || '';
   const apiProvider = args.apiProvider || process.env.API_PROVIDER || process.env.MCP_API_PROVIDER || '';
@@ -686,6 +902,44 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     logSource: 'mcp'
   });
 
+  // 检查频率限制
+  const rateLimitResult = checkRateLimit(name);
+  if (!rateLimitResult.allowed) {
+    const windowName = rateLimitResult.windowMs === 60 * 1000 ? '1 分钟' : '1 天';
+    const waitTime = rateLimitResult.waitSeconds < 60
+      ? `${rateLimitResult.waitSeconds} 秒`
+      : `${Math.ceil(rateLimitResult.waitSeconds / 60)} 分钟`;
+
+    // 记录限流
+    logMcpCall({
+      traceId,
+      stage: 'rate_limited',
+      toolName: name,
+      error: 'RATE_LIMIT_EXCEEDED',
+      duration: Date.now() - startTime,
+      agentType,
+      apiProvider,
+      mcpVersion: MCP_VERSION,
+      osType: osInfo.osType,
+      osVersion: osInfo.osVersion,
+      timestamp: new Date().toISOString(),
+      logSource: 'mcp'
+    });
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            success: false,
+            error: `请求过于频繁，${windowName}内最多调用 ${rateLimitResult.maxRequests} 次，请 ${waitTime} 后再试`,
+            code: 429
+          })
+        }
+      ]
+    };
+  }
+
   // 强制检查：记账工具必须先调用 get_skill
   if (name === 'save_expense' || name === 'save_receipt' || name === 'save_income') {
     const now = Date.now();
@@ -739,7 +993,13 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     if (processedArgs.items && typeof processedArgs.items === 'string') {
       try {
         processedArgs.items = JSON.parse(processedArgs.items);
+
+        // 验证解析后的类型
+        if (!Array.isArray(processedArgs.items)) {
+          throw new Error('items 必须是数组');
+        }
       } catch (e) {
+        throw new Error(`items 参数格式错误：${e.message}`);
       }
     }
 
@@ -805,41 +1065,17 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           userMessage = '❌ 记账失败：金额必须是正数';
           break;
         }
-        
-        // P1: 日期合理性检查
-        if (processedArgs.date) {
-          const inputDate = new Date(processedArgs.date);
-          const now = new Date();
-          const sixtyYearsAgo = new Date();
-          sixtyYearsAgo.setFullYear(now.getFullYear() - 60);
-          
-          if (isNaN(inputDate.getTime())) {
-            result = {
-              success: false,
-              error: '日期格式无效',
-              code: 400
-            };
-            userMessage = '❌ 记账失败：日期格式无效，请使用毫秒级时间戳（13位数字，如：xxxxxxxxxxxxx）';
-            break;
-          }
 
-          if (inputDate > now) {
-            result = {
-              success: false,
-              error: '日期不能是未来时间',
-              code: 400
-            };
-            userMessage = '❌ 记账失败：日期不能是未来时间';
-            break;
-          }
-          
-          if (inputDate < sixtyYearsAgo) {
+        // 日期合理性检查
+        if (processedArgs.date) {
+          const validation = validateDate(processedArgs.date, '消费时间');
+          if (!validation.valid) {
             result = {
               success: false,
-              error: '日期不能是60年前',
+              error: validation.message,
               code: 400
             };
-            userMessage = '❌ 记账失败：日期不能是60年前';
+            userMessage = `❌ 记账失败：${validation.message}`;
             break;
           }
         }
@@ -968,41 +1204,17 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           userMessage = `❌ 保存失败\n\n错误：商品数据格式不完整\n\n${invalidItems.join('\n')}\n\n💡 解决方案：\n1. 请更新您的柴米记账 MCP Skill\n2. 确保每个商品包含完整的5个字段：name, amount, price, quantity, category\n3. category 是记账的基本信息，不能为空`;
           break;
         }
-        
-        // P1: 日期合理性检查
+
+        // 日期合理性检查
         if (processedArgs.date) {
-          const inputDate = new Date(processedArgs.date);
-          const now = new Date();
-          const sixtyYearsAgo = new Date();
-          sixtyYearsAgo.setFullYear(now.getFullYear() - 60);
-          
-          if (isNaN(inputDate.getTime())) {
+          const validation = validateDate(processedArgs.date, '小票日期');
+          if (!validation.valid) {
             result = {
               success: false,
-              error: '日期格式无效',
+              error: validation.message,
               code: 400
             };
-            userMessage = '❌ 保存失败：日期格式无效，请使用毫秒级时间戳（13位数字，如：xxxxxxxxxxxxx）';
-            break;
-          }
-          
-          if (inputDate > now) {
-            result = {
-              success: false,
-              error: '日期不能是未来时间',
-              code: 400
-            };
-            userMessage = '❌ 保存失败：日期不能是未来时间，请检查小票日期是否正确';
-            break;
-          }
-          
-          if (inputDate < sixtyYearsAgo) {
-            result = {
-              success: false,
-              error: '日期不能是60年前',
-              code: 400
-            };
-            userMessage = '❌ 保存失败：日期不能是60年前，请检查小票日期是否正确';
+            userMessage = `❌ 保存失败：${validation.message}，请检查小票日期是否正确`;
             break;
           }
         }
@@ -1440,18 +1652,11 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       userMessage = `❌ 操作失败：${result.error || '未知错误'}`;
     }
 
-    // 构建完整的返回内容：userMessage + 完整的 result 数据
-    const fullResponse = {
-      userMessage: userMessage,
-      result: result,
-      mcpVersion: MCP_VERSION
-    };
-
     return {
       content: [
         {
           type: 'text',
-          text: `${userMessage}\n\n---\n📦 柴米记账 MCP v${MCP_VERSION}\n\n## 完整数据\n\`\`\`json\n${JSON.stringify(result, null, 2)}\n\`\`\``,
+          text: `${userMessage}\n\n---\n📦 柴米记账 MCP v${MCP_VERSION}\n\n## 完整数据\n\`\`\`json\n${safeStringify(result)}\n\`\`\``,
         },
       ],
     };
@@ -1558,11 +1763,24 @@ ${'='.repeat(60)}
       };
     }
     
+    // 区分开发/生产环境，避免泄露内部错误信息
+    const errorMessage = process.env.NODE_ENV === 'development'
+      ? `Error: ${error.message}`
+      : '操作失败，请稍后重试或联系客服';
+
+    // 记录完整错误到日志（用于调试）
+    console.error('Tool execution error:', {
+      tool: request.params.name,
+      error: error.message,
+      stack: error.stack,
+      timestamp: new Date().toISOString()
+    });
+
     return {
       content: [
         {
           type: 'text',
-          text: `Error: ${error.message}`,
+          text: errorMessage,
         },
       ],
       isError: true,
@@ -1570,8 +1788,31 @@ ${'='.repeat(60)}
   }
 });
 
+// 安全的 JSON 序列化函数，防止循环引用和超大数据导致内存溢出
+function safeStringify(obj, maxLength = 100000) {
+  try {
+    const str = JSON.stringify(obj, null, 2);
+    if (str.length > maxLength) {
+      return JSON.stringify({
+        ...obj,
+        data: '[数据过大，已省略]',
+        _note: `完整数据大小：${str.length} 字符`
+      }, null, 2);
+    }
+    return str;
+  } catch (error) {
+    return JSON.stringify({ error: '数据序列化失败' });
+  }
+}
+
 function sanitizeString(str, maxLength = 200) {
   if (!str || typeof str !== 'string') return '';
+
+  // 硬性限制：输入不能超过 maxLength 的 10 倍，防止超大字符串导致内存溢出
+  if (str.length > maxLength * 10) {
+    throw new Error(`输入过长，最大允许 ${maxLength} 字符`);
+  }
+
   return str.replace(/<[^>]*>/g, '').substring(0, maxLength);
 }
 

package/utils/validators.js

@@ -0,0 +1,42 @@
+/**
+ * 数据校验工具函数
+ */
+
+/**
+ * 校验日期合理性
+ * @param {number|string} dateInput - 日期（毫秒级时间戳或日期字符串）
+ * @param {string} fieldName - 字段名称（用于错误提示）
+ * @returns {Date} 校验通过后的 Date 对象
+ * @throws {Error} 校验失败时抛出错误
+ */
+function validateDate(dateInput, fieldName = '日期') {
+  if (!dateInput) {
+    return new Date(); // 默认当前时间
+  }
+
+  const inputDate = new Date(dateInput);
+  const now = new Date();
+  const sixtyYearsAgo = new Date();
+  sixtyYearsAgo.setFullYear(now.getFullYear() - 60);
+
+  // 校验 1：日期格式是否有效
+  if (isNaN(inputDate.getTime())) {
+    throw new Error(`${fieldName}格式无效，请使用毫秒级时间戳（13位数字，如：${Date.now()}）`);
+  }
+
+  // 校验 2：日期不能是未来时间
+  if (inputDate > now) {
+    throw new Error(`${fieldName}不能是未来时间`);
+  }
+
+  // 校验 3：日期不能是 60 年前
+  if (inputDate < sixtyYearsAgo) {
+    throw new Error(`${fieldName}不能是60年前`);
+  }
+
+  return inputDate;
+}
+
+module.exports = {
+  validateDate
+};