chaimi-keep-mcp 3.1.45-beta.6 → 3.1.46-beta.0

package/oauth.js

@@ -312,19 +312,16 @@ class OAuthManager {
       const fs = require('fs').promises;
       const path = require('path');
       const stateFile = path.join(require('os').homedir(), '.mcporter', 'auth-state.json');
-
+      
       const dir = path.dirname(stateFile);
       await fs.mkdir(dir, { recursive: true });
-
+      
       await fs.writeFile(
         stateFile,
         JSON.stringify(state, null, 2),
         { mode: 0o600 }
       );
-      console.error('✅ 授权状态已保存');
     } catch (err) {
-      console.error('❌ 保存授权状态失败:', err.message);
-      throw err;
     }
   }
 

package/package.json

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

package/server.js

@@ -5,119 +5,11 @@
  * 支持 Claude Desktop、Cursor、WorkBuddy、OpenClaw
  */
 
-// 加载环境变量 - 根据 NODE_ENV 自动选择配置文件
-const NODE_ENV = process.env.NODE_ENV || 'development';
-const envFile = `.env.${NODE_ENV}`;
-
-// ==================== 自动配置获取 ====================
-async function fetchConfigFromCloud() {
-  const configUrl = 'https://cloud1-2gfe5jhjef06b85d-1412172089.ap-shanghai.app.tcloudbase.com/mcpHub-mcp';
-
-  try {
-    console.error('🔧 首次启动，正在从云端获取配置...');
-
-    const https = require('https');
-    const response = await new Promise((resolve, reject) => {
-      const req = https.request(configUrl, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json'
-        }
-      }, (res) => {
-        let data = '';
-        res.on('data', chunk => data += chunk);
-        res.on('end', () => {
-          try {
-            resolve(JSON.parse(data));
-          } catch (e) {
-            reject(new Error('配置解析失败'));
-          }
-        });
-      });
-
-      req.on('error', reject);
-      req.write(JSON.stringify({ action: 'getMcpConfig' }));
-      req.end();
-    });
-
-    if (!response.success || !response.data) {
-      throw new Error('配置获取失败');
-    }
-
-    return response.data;
-  } catch (err) {
-    // 抛出错误让调用者处理，不要直接退出
-    throw new Error(`配置获取失败: ${err.message}`);
-  }
-}
-
-async function initializeConfig() {
-  const fs = require('fs');
-  const path = require('path');
-  const os = require('os');
-
-  // XDG 标准配置目录
-  // Linux/macOS: ~/.config/chaimi-keep-mcp/
-  // Windows: %APPDATA%/chaimi-keep-mcp/ (通过设置 XDG_CONFIG_HOME 环境变量)
-  const xdgConfigHome = process.env.XDG_CONFIG_HOME;
-  const configDir = xdgConfigHome
-    ? path.join(xdgConfigHome, 'chaimi-keep-mcp')
-    : path.join(os.homedir(), '.config', 'chaimi-keep-mcp');
-
-  // 确保配置目录存在
-  if (!fs.existsSync(configDir)) {
-    fs.mkdirSync(configDir, { recursive: true, mode: 0o700 });
-  }
-
-  const envPath = path.join(configDir, envFile);
-
-  // 如果配置文件已存在，直接返回路径
-  if (fs.existsSync(envPath)) {
-    return envPath;
-  }
-
-  // 首次启动，尝试从云端获取配置
-  let config;
-  try {
-    config = await fetchConfigFromCloud();
-    console.error('✅ 已从云端获取配置');
-  } catch (err) {
-    console.error('❌ 无法从云端获取配置');
-    console.error('   错误：' + err.message);
-    console.error('');
-    console.error('可能原因：');
-    console.error('   1. 网络连接异常');
-    console.error('   2. 云函数尚未部署或配置错误');
-    console.error('');
-    console.error('解决方案：');
-    console.error('   1. 检查网络连接');
-    console.error('   2. 确认云函数 mcpHub 已部署');
-    console.error('   3. 联系开发者获取帮助');
-    process.exit(1);
-  }
-
-  // 生成配置文件
-  const envContent = `# 柴米记账 MCP Server - ${NODE_ENV} 环境配置
-# 自动生成时间：${new Date().toISOString()}
-
-# 云函数 URL
-MCP_HUB_URL=${config.MCP_HUB_URL}
-MCP_PROMPT_URL=${config.MCP_PROMPT_URL}
-MCP_OAUTH_URL=${config.MCP_OAUTH_URL}
-
-# API 签名密钥
-CHAIMI_API_SECRET=${config.CHAIMI_API_SECRET}
-
-# JWT 密钥
-JWT_SECRET=${config.JWT_SECRET}
-`;
-
-  fs.writeFileSync(envPath, envContent, { mode: 0o600 });
-  console.error('✅ 配置文件已自动生成！');
-  console.error(`   文件位置：${envPath}`);
-  console.error('');
-
-  return envPath;
+// 加载 .env 文件
+try {
+  require('dotenv').config();
+} catch (e) {
+  // dotenv 未安装，忽略
 }
 
 const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
@@ -138,90 +30,37 @@ 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）
-// 注意：initializeConfig() 后会自动加载，这里先声明变量
-let CHAIMI_API_SECRET;
-
-// ==================== 加密/解密函数 ====================
-
-// 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}`;
-}
+const CHAIMI_API_SECRET = 'chaimi-mcp-secret-2024';
 
-// AES-256-GCM 解密（用于 Token）
-function decrypt(encryptedText, secretKey) {
-  const [ivHex, authTagHex, encrypted] = encryptedText.split(':');
+// URL 加密密钥
+const URL_ENCRYPT_KEY = 'chaimi-url-key-2024';
 
-  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');
+// 加密的云函数 URL
+const ENCRYPTED_URLS = {
+  hub: 'enc:v1:0b1c15191e53025a1100421e0148000057545156020903080f1d431054180f484819030203035158595043085d5801044c0502114c5b1e53441346150a01065811100d5e0e4b1a425f1f5f571320140b40044e05',
+  oauth: 'enc:v1:0b1c15191e53025a1100421e0148000057545156020903080f1d431054180f484819030203035158595043085d5801044c0502114c5b1e53441346150a01065811100d5e0e4b1a425f1f5f571327201c1901',
+  prompt: 'enc:v1:0b1c15191e53025a1100421e0148000057545156020903080f1d431054180f484819030203035158595043085d5801044c0502114c5b1e53441346150a01065811100d5e0e4b1a425f1f5f5713381306001959'
+};
 
-  return decrypted;
+// 解密 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));
+  }
+  return result;
 }
 
-// ==================== 云函数 URL 配置 ====================
-// 注意：initializeConfig() 后会自动加载，这里先声明变量
-let MCP_HUB_URL;
-let MCP_PROMPT_URL;
-let MCP_OAUTH_URL;
+// 配置 - 微信云函数（运行时解密）
+const MCP_HUB_URL = process.env.MCP_HUB_URL || decryptUrl(ENCRYPTED_URLS.hub, URL_ENCRYPT_KEY);
+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 cachedEncryptedToken = null;
+// Token 缓存
+let cachedToken = null;
 let tokenExpireTime = 0;
 
 // OAuth 管理器实例
@@ -269,8 +108,8 @@ async function initOAuthManager() {
       // 检查 Token 是否过期（预留5分钟缓冲）
       const expiresAt = new Date(existingToken.expiresAt).getTime();
       if (expiresAt > Date.now() + 5 * 60 * 1000) {
-        // Token 有效，加密后缓存
-        cachedEncryptedToken = encrypt(existingToken.accessToken, SECRET_KEY);
+        // Token 有效，设置授权状态
+        cachedToken = existingToken.accessToken;
         tokenExpireTime = expiresAt;
         authState.isAuthorized = true;
         console.error('✅ 已从文件加载有效 Token，无需重新授权');
@@ -532,103 +371,15 @@ 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 (cachedEncryptedToken && tokenExpireTime > Date.now() + 5 * 60 * 1000) {
+  if (cachedToken && tokenExpireTime > Date.now() + 5 * 60 * 1000) {
     if (Date.now() - lastRefreshTime < TOKEN_REFRESH_INTERVAL) {
-      // 解密后返回
-      return decrypt(cachedEncryptedToken, SECRET_KEY);
+      return cachedToken;
     }
   }
 
@@ -639,14 +390,12 @@ async function getToken() {
   // 步骤2：尝试从文件加载并刷新 Token
   try {
     const oauthToken = await oauthManager.getValidToken();
-    // 加密后缓存
-    cachedEncryptedToken = encrypt(oauthToken.accessToken, SECRET_KEY);
+    cachedToken = oauthToken.accessToken;
     tokenExpireTime = oauthToken.expiresAt;
     lastRefreshTime = Date.now();
     authState.isAuthorized = true;
     await oauthManager.clearAuthState();
-    // 解密后返回
-    return decrypt(cachedEncryptedToken, SECRET_KEY);
+    return cachedToken;
   } catch (err) {
     // Token 无效，需要重新授权
     console.error('⏰ Token 无效，需要重新授权:', err.message);
@@ -736,15 +485,10 @@ async function callMcpPrompt(tool, params, token) {
 // 生成请求签名（用于验证请求来自合法 MCP Server）
 function generateSignature(body, timestamp, secret) {
   const payload = JSON.stringify(body) + timestamp;
-  const signature = crypto
+  return crypto
     .createHmac('sha256', secret)
     .update(payload)
     .digest('hex');
-  // 调试日志（仅在开发环境显示）
-  if (process.env.DEBUG_MCP === 'true') {
-    console.error('[DEBUG] 生成签名:', { payload: payload.substring(0, 100), timestamp, signature: signature.substring(0, 16) + '...' });
-  }
-  return signature;
 }
 
 // MCP 调用日志记录函数
@@ -922,7 +666,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 || '';
@@ -942,44 +686,6 @@ 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();
@@ -1033,13 +739,7 @@ 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}`);
       }
     }
 
@@ -1105,17 +805,41 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           userMessage = '❌ 记账失败：金额必须是正数';
           break;
         }
-
-        // 日期合理性检查
+        
+        // P1: 日期合理性检查
         if (processedArgs.date) {
-          const validation = validateDate(processedArgs.date, '消费时间');
-          if (!validation.valid) {
+          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) {
             result = {
               success: false,
-              error: validation.message,
+              error: '日期不能是60年前',
               code: 400
             };
-            userMessage = `❌ 记账失败：${validation.message}`;
+            userMessage = '❌ 记账失败：日期不能是60年前';
             break;
           }
         }
@@ -1244,17 +968,41 @@ 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 validation = validateDate(processedArgs.date, '小票日期');
-          if (!validation.valid) {
+          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) {
             result = {
               success: false,
-              error: validation.message,
+              error: '日期不能是60年前',
               code: 400
             };
-            userMessage = `❌ 保存失败：${validation.message}，请检查小票日期是否正确`;
+            userMessage = '❌ 保存失败：日期不能是60年前，请检查小票日期是否正确';
             break;
           }
         }
@@ -1692,11 +1440,18 @@ 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${safeStringify(result)}\n\`\`\``,
+          text: `${userMessage}\n\n---\n📦 柴米记账 MCP v${MCP_VERSION}\n\n## 完整数据\n\`\`\`json\n${JSON.stringify(result, null, 2)}\n\`\`\``,
         },
       ],
     };
@@ -1803,24 +1558,11 @@ ${'='.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: errorMessage,
+          text: `Error: ${error.message}`,
         },
       ],
       isError: true,
@@ -1828,31 +1570,8 @@ ${'='.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);
 }
 
@@ -2098,36 +1817,6 @@ let authState = {
 };
 
 async function main() {
-  // 首次启动时自动获取配置
-  const envPath = await initializeConfig();
-
-  // 加载环境变量（无论文件是否存在都需要加载）
-  require('dotenv').config({ path: envPath });
-
-  // 加载环境变量后赋值
-  CHAIMI_API_SECRET = process.env.CHAIMI_API_SECRET;
-  MCP_HUB_URL = process.env.MCP_HUB_URL;
-  MCP_PROMPT_URL = process.env.MCP_PROMPT_URL;
-  MCP_OAUTH_URL = process.env.MCP_OAUTH_URL;
-
-  // 验证必需的环境变量
-  if (!CHAIMI_API_SECRET) {
-    console.error('❌ 错误：缺少必需的环境变量 CHAIMI_API_SECRET');
-    console.error('   配置文件可能未正确生成，请检查 .env.development 文件');
-    console.error('   或手动运行：node setup.js');
-    process.exit(1);
-  }
-
-  // 验证云函数 URL 配置
-  if (!MCP_HUB_URL || !MCP_PROMPT_URL || !MCP_OAUTH_URL) {
-    console.error('❌ 错误：缺少云函数 URL 配置');
-    console.error('   请在 .env 文件中配置以下环境变量：');
-    console.error('   MCP_HUB_URL=https://your-cloud-function-url/mcpHub-mcp');
-    console.error('   MCP_PROMPT_URL=https://your-cloud-function-url/mcpPrompt');
-    console.error('   MCP_OAUTH_URL=https://your-cloud-function-url/mcpOAuth');
-    process.exit(1);
-  }
-
   await initOAuthManager();
 
   const transport = new StdioServerTransport();
@@ -2283,13 +1972,8 @@ function sanitizeLogParams(params) {
 }
 
 // 注意：使用 console.error，避免污染 stdout（MCP 协议通信使用 stdout）
-function startServer() {
-  main().catch((err) => {
-    console.error('❌ MCP Server 启动失败:', err.message);
-    console.error('堆栈:', err.stack);
-    process.exit(1);
-  });
-}
-
-// 启动服务器
-startServer();
+main().catch((err) => {
+  console.error('❌ MCP Server 启动失败:', err.message);
+  console.error('堆栈:', err.stack);
+  process.exit(1);
+});

package/utils/validators.js

@@ -1,49 +0,0 @@
-/**
- * 数据校验工具函数
- */
-
-/**
- * 校验日期合理性
- * @param {number|string} dateInput - 日期（毫秒级时间戳或日期字符串）
- * @param {string} fieldName - 字段名称（用于错误提示）
- * @returns {Object} { valid: boolean, error?: string, message?: string }
- */
-function validateDate(dateInput, fieldName = '日期') {
-  const inputDate = new Date(dateInput);
-  const now = new Date();
-  const sixtyYearsAgo = new Date();
-  sixtyYearsAgo.setFullYear(now.getFullYear() - 60);
-
-  // 校验 1：日期格式是否有效
-  if (isNaN(inputDate.getTime())) {
-    return {
-      valid: false,
-      error: '日期格式无效',
-      message: `❌ ${fieldName}格式无效，请使用毫秒级时间戳（13位数字）`
-    };
-  }
-
-  // 校验 2：日期不能是未来时间
-  if (inputDate > now) {
-    return {
-      valid: false,
-      error: '日期不能是未来时间',
-      message: `❌ ${fieldName}不能是未来时间`
-    };
-  }
-
-  // 校验 3：日期不能是 60 年前
-  if (inputDate < sixtyYearsAgo) {
-    return {
-      valid: false,
-      error: '日期不能是60年前',
-      message: `❌ ${fieldName}不能是60年前`
-    };
-  }
-
-  return { valid: true };
-}
-
-module.exports = {
-  validateDate
-};