chaimi-keep-mcp 3.1.45-beta.7 → 3.1.46-beta.1

package/README.md

@@ -141,6 +141,14 @@ AI 会自动调用 `save_income` 工具记录收入。
 
 ## 更新日志
 
+### v3.1.46-beta.0 (2026-04-22)
+- **修复** 授权流程阻塞问题：恢复到 v3.1.37 之前的非阻塞模式
+  - 移除 `startAuthFlowAndWait()` 和 `waitForAuthWithPolling()` 阻塞函数
+  - 恢复 `startAuthFlow()` + `pollForAuthInBackground()` 非阻塞模式
+  - 立即返回验证码给 Agent，配合 `lifecycle: keep-alive` 后台轮询
+  - 解决 mcporter 超时和验证码不显示问题
+- **基于** npm 3.1.44 版本，保留其他所有功能和修复
+
 ### v3.1.44 (2026-04-21) 🎉 正式版
 - **正式发布** 包含所有 beta 版本修复
   - MCP 调用日志字段缺失修复

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chaimi-keep-mcp",
-  "version": "3.1.45-beta.7",
+  "version": "3.1.46-beta.1",
   "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,105 +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 envPath = path.join(__dirname, envFile);
-
-  // 如果配置文件已存在，直接返回
-  if (fs.existsSync(envPath)) {
-    return;
-  }
-
-  // 首次启动，尝试从云端获取配置
-  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('');
-
-  // 重新加载环境变量
-  require('dotenv').config({ path: envPath });
+// 加载 .env 文件
+try {
+  require('dotenv').config();
+} catch (e) {
+  // dotenv 未安装，忽略
 }
 
 const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
@@ -124,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}`;
-}
-
-// 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')
-  );
+const CHAIMI_API_SECRET = 'chaimi-mcp-secret-2024';
 
-  decipher.setAuthTag(Buffer.from(authTagHex, 'hex'));
+// URL 加密密钥
+const URL_ENCRYPT_KEY = 'chaimi-url-key-2024';
 
-  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 管理器实例
@@ -255,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，无需重新授权');
@@ -518,103 +371,60 @@ 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 (!authState.isAuthorized) {
+    // 先检查是否有保存的授权状态（从文件加载）
+    const savedAuthState = await oauthManager.loadAuthState();
+    if (savedAuthState && savedAuthState.deviceCode) {
+      // 检查验证码是否已过期
+      if (oauthManager.isAuthStateExpired(savedAuthState)) {
+        console.error('⏰ 保存的验证码已过期，清除并生成新的验证码');
+        await oauthManager.clearAuthState();
+        // 继续执行，生成新的验证码
+      } else {
+        // 验证码未过期，尝试直接获取token（用户可能已授权）
+        try {
+          const token = await oauthManager.pollForTokenOnce(savedAuthState.deviceCode);
+          if (token) {
+            // 授权成功
+            cachedToken = token.accessToken;
+            tokenExpireTime = token.expiresAt;
+            authState.isAuthorized = true;
+            await oauthManager.tokenStorage.save(token);
+            await oauthManager.clearAuthState();
+            console.error('✅ 授权成功！可以继续使用记账功能');
+            // 返回特殊标记，让上层知道这是刚完成授权的情况
+            throw new Error(`AUTH_JUST_COMPLETED:${cachedToken}`);
+          }
+          // 用户还未授权，返回同一个验证码
+          authState.deviceCode = savedAuthState.deviceCode;
+          authState.userCode = savedAuthState.userCode;
+          throw new Error(`NEED_AUTH:${savedAuthState.userCode}`);
+        } catch (err) {
+          if (err.message.startsWith('NEED_AUTH:') || err.message.startsWith('AUTH_JUST_COMPLETED:')) {
+            throw err;
+          }
+          // 其他错误，继续获取新的验证码
+          console.error('⚠️  检查授权状态失败:', err.message);
+        }
+      }
+    }
+    
+    // 没有保存的授权状态或已过期，启动新的授权流程
+    await startAuthFlow();
+    
+    // 返回验证码给Agent
+    throw new Error(`NEED_AUTH:${authState.userCode || '等待生成验证码'}`);
+  }
+
+  if (cachedToken && tokenExpireTime > Date.now() + 5 * 60 * 1000) {
     if (Date.now() - lastRefreshTime < TOKEN_REFRESH_INTERVAL) {
-      // 解密后返回
-      return decrypt(cachedEncryptedToken, SECRET_KEY);
+      return cachedToken;
     }
   }
 
@@ -622,78 +432,18 @@ async function getToken() {
     throw new Error('OAuth 管理器未初始化，请检查 MCP_OAUTH_URL 配置');
   }
 
-  // 步骤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);
-  } catch (err) {
-    // Token 无效，需要重新授权
-    console.error('⏰ Token 无效，需要重新授权:', err.message);
-  }
-
-  // 步骤3：检查是否有保存的授权状态（用户可能正在授权中）
-  const savedAuthState = await oauthManager.loadAuthState();
-  if (savedAuthState && savedAuthState.deviceCode) {
-    // 检查验证码是否已过期
-    if (oauthManager.isAuthStateExpired(savedAuthState)) {
-      console.error('⏰ 保存的验证码已过期，清除并生成新的验证码');
-      await oauthManager.clearAuthState();
-    } else {
-      // 验证码未过期，尝试直接获取token（用户可能已授权）
-      try {
-        const token = await oauthManager.pollForTokenOnce(savedAuthState.deviceCode);
-        if (token) {
-          // 授权成功
-          cachedToken = token.accessToken;
-          tokenExpireTime = token.expiresAt;
-          authState.isAuthorized = true;
-          await oauthManager.tokenStorage.save(token);
-          await oauthManager.clearAuthState();
-          console.error('✅ 授权成功！可以继续使用记账功能');
-          // 返回特殊标记，让上层知道这是刚完成授权的情况
-          throw new Error(`AUTH_JUST_COMPLETED:${cachedToken}`);
-        }
-        // 用户还未授权，启动轮询等待
-        console.error(`⏳ 等待用户授权，验证码：${savedAuthState.userCode}`);
-        const authResult = await waitForAuthWithPolling(savedAuthState.deviceCode, savedAuthState.userCode, 120000);
-        if (authResult.success) {
-          cachedToken = authResult.token.accessToken;
-          tokenExpireTime = authResult.token.expiresAt;
-          authState.isAuthorized = true;
-          await oauthManager.tokenStorage.save(authResult.token);
-          await oauthManager.clearAuthState();
-          return cachedToken;
-        } else {
-          throw new Error(`NEED_AUTH:${savedAuthState.userCode}`);
-        }
-      } catch (err) {
-        if (err.message.startsWith('NEED_AUTH:') || err.message.startsWith('AUTH_JUST_COMPLETED:')) {
-          throw err;
-        }
-        console.error('⚠️  检查授权状态失败:', err.message);
-      }
-    }
-  }
-
-  // 步骤4：启动新的授权流程并等待
-  console.error('🔐 启动新的授权流程...');
-  const authResult = await startAuthFlowAndWait(120000);
-
-  if (authResult.success) {
-    cachedToken = authResult.token.accessToken;
-    tokenExpireTime = authResult.token.expiresAt;
-    authState.isAuthorized = true;
     return cachedToken;
-  } else {
-    // 超时或失败，抛出错误让 Agent 知道需要用户介入
-    throw new Error(`NEED_AUTH:${authResult.userCode || '授权超时，请再次调用'}`);
+  } catch (err) {
+    // Token 获取失败，可能需要重新授权
+    authState.isAuthorized = false;
+    authState.isWaiting = false;
+    throw new Error(`NEED_AUTH:授权已过期，请重新授权`);
   }
 }
 
@@ -903,7 +653,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 || '';
@@ -923,44 +673,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();
@@ -1014,13 +726,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}`);
       }
     }
 
@@ -1086,17 +792,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: validation.message,
+              error: '日期格式无效',
               code: 400
             };
-            userMessage = `❌ 记账失败：${validation.message}`;
+            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年前';
             break;
           }
         }
@@ -1225,17 +955,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: validation.message,
+              error: '日期格式无效',
               code: 400
             };
-            userMessage = `❌ 保存失败：${validation.message}，请检查小票日期是否正确`;
+            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年前，请检查小票日期是否正确';
             break;
           }
         }
@@ -1673,11 +1427,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\`\`\``,
         },
       ],
     };
@@ -1784,24 +1545,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,
@@ -1809,31 +1557,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);
 }
 
@@ -2079,145 +1804,112 @@ let authState = {
 };
 
 async function main() {
-  // 首次启动时自动获取配置
-  await initializeConfig();
-
-  // 加载环境变量后赋值
-  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();
   await server.connect(transport);
 }
 
-// 延迟函数
-function delay(ms) {
-  return new Promise(resolve => setTimeout(resolve, ms));
+// 启动授权流程（获取验证码，启动后台轮询）
+async function startAuthFlow() {
+  try {
+    // 先检查是否有保存的授权状态
+    const savedAuthState = await oauthManager.loadAuthState();
+    if (savedAuthState && savedAuthState.userCode) {
+      // 检查验证码是否过期
+      if (oauthManager.isAuthStateExpired(savedAuthState)) {
+        console.error('⏰ 验证码已过期，生成新的验证码');
+        await oauthManager.clearAuthState();
+      } else {
+        // 有保存的验证码，直接使用
+        authState.deviceCode = savedAuthState.deviceCode;
+        authState.userCode = savedAuthState.userCode;
+        authState.isWaiting = true;
+        console.error(`🔑 使用已保存的验证码：${savedAuthState.userCode}`);
+        // 启动后台轮询
+        pollForAuthInBackground(savedAuthState.deviceCode, 5000);
+        return;
+      }
+    }
+
+    // 获取新的设备码
+    const deviceCodeRes = await oauthManager.requestDeviceCode(false);
+    authState.deviceCode = deviceCodeRes.deviceCode;
+    authState.userCode = deviceCodeRes.userCode;
+    authState.isWaiting = true;
+
+    // 保存授权状态（30分钟有效）
+    await oauthManager.saveAuthState({
+      deviceCode: deviceCodeRes.deviceCode,
+      userCode: deviceCodeRes.userCode,
+      expiresAt: Date.now() + deviceCodeRes.expiresIn * 1000
+    });
+
+    console.error(`🔑 验证码：${deviceCodeRes.userCode}`);
+    console.error('⏳ 请在小程序中完成授权，然后再次调用');
+    
+    // 启动后台轮询（3分钟）
+    pollForAuthInBackground(deviceCodeRes.deviceCode, 5000);
+
+  } catch (err) {
+    authState.error = err.message;
+    authState.isWaiting = false;
+    console.error('❌ 启动授权失败:', err.message);
+  }
 }
 
-// 等待授权完成（带轮询）- 方案三实现
-async function waitForAuthWithPolling(deviceCode, userCode, timeout = 120000) {
-  const startTime = Date.now();
-  const interval = 5000; // 5秒轮询一次
+// 后台轮询授权状态（3分钟）
+async function pollForAuthInBackground(deviceCode, interval) {
+  const maxAttempts = 36; // 3分钟（36次 × 5秒）
+  let attempts = 0;
 
-  console.error(`⏳ 等待用户授权中...（验证码：${userCode}）`);
-  console.error('   请打开"柴米AI记账"小程序完成授权');
+  console.error('⏳ 等待用户授权中...（3分钟内有效）');
 
-  while (Date.now() - startTime < timeout) {
+  while (attempts < maxAttempts && authState.isWaiting) {
+    attempts++;
     await delay(interval);
 
     try {
       // 调用云函数检查授权状态
       const token = await oauthManager.pollForTokenOnce(deviceCode);
-
+      
       if (token) {
         // 授权成功
-        console.error('✅ 检测到用户授权成功！');
-        return { success: true, token };
+        cachedToken = token.accessToken;
+        tokenExpireTime = token.expiresAt;
+        authState.isAuthorized = true;
+        authState.isWaiting = false;
+        
+        // 保存token到文件
+        await oauthManager.tokenStorage.save(token);
+        // 清除授权状态
+        await oauthManager.clearAuthState();
+        
+        console.error('✅ 授权成功！下次调用将快速启动');
+        
+        // 主动退出进程，让 mcporter 下次重新启动
+        process.exit(0);
       }
     } catch (err) {
       if (err.message.includes('expired') || err.message.includes('invalid')) {
+        authState.error = err.message;
+        authState.isWaiting = false;
         console.error('❌ 授权失败:', err.message);
-        return { success: false, error: err.message };
+        process.exit(1);
       }
       // 继续轮询
     }
-
-    // 输出等待提示（每30秒一次）
-    const elapsed = Math.floor((Date.now() - startTime) / 1000);
-    if (elapsed % 30 === 0) {
-      console.error(`   已等待 ${elapsed} 秒...`);
-    }
   }
 
-  // 超时
-  console.error('⏰ 等待授权超时（2分钟）');
-  return { success: false, error: 'timeout', userCode };
+  // 3分钟超时
+  authState.isWaiting = false;
+  console.error('⏰ 授权超时，请再次调用获取新验证码');
+  process.exit(0);
 }
 
-// 启动授权流程并等待 - 方案三实现
-async function startAuthFlowAndWait(timeout = 120000) {
-  try {
-    // 检查是否已有进行中的授权流程（防止并发）
-    if (authState.isWaiting) {
-      console.error('⏳ 已有进行中的授权流程，等待完成...');
-      // 等待现有流程完成
-      const startTime = Date.now();
-      while (authState.isWaiting && Date.now() - startTime < timeout) {
-        await delay(1000);
-      }
-      // 如果授权成功，返回成功
-      if (authState.isAuthorized && cachedToken) {
-        return { success: true, token: { accessToken: cachedToken, expiresAt: tokenExpireTime } };
-      }
-      // 否则继续启动新的授权流程
-    }
-
-    // 设置等待状态（防止并发）
-    authState.isWaiting = true;
-    authState.error = null;
-
-    // 获取新的设备码
-    const deviceCodeRes = await oauthManager.requestDeviceCode(false);
-    const deviceCode = deviceCodeRes.deviceCode;
-    const userCode = deviceCodeRes.userCode;
-
-    // 保存授权状态（30分钟有效）
-    await oauthManager.saveAuthState({
-      deviceCode: deviceCode,
-      userCode: userCode,
-      expiresAt: Date.now() + deviceCodeRes.expiresIn * 1000
-    });
-
-    console.error(`🔑 验证码：${userCode}`);
-    console.error('━━━━━━━━━━━━━━');
-    console.error('📱 请打开"柴米AI记账"小程序：');
-    console.error('   1. 点击"我的" → "🤖 Agent 授权"');
-    console.error(`   2. 输入验证码：${userCode}`);
-    console.error('   3. 点击确认授权');
-    console.error('━━━━━━━━━━━━━━');
-    console.error(`⏳ 等待您授权完成（${Math.floor(timeout / 1000)}秒内）...`);
-
-    // 等待用户授权
-    const result = await waitForAuthWithPolling(deviceCode, userCode, timeout);
-
-    // 清除等待状态
-    authState.isWaiting = false;
-
-    if (result.success) {
-      return { success: true, token: result.token };
-    } else {
-      return { success: false, userCode, error: result.error };
-    }
-
-  } catch (err) {
-    // 清除等待状态
-    authState.isWaiting = false;
-    console.error('❌ 启动授权流程失败:', err.message);
-    return { success: false, error: err.message };
-  }
+// 延迟函数
+function delay(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
 }
 
 /**
@@ -2261,13 +1953,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
-};