chaimi-bookkeeping-mcp 2.3.6 → 2.3.9

package/oauth.js

@@ -13,74 +13,37 @@ class OAuthManager {
   constructor(config) {
     this.mcpOAuthUrl = config.mcpOAuthUrl;
     this.tokenStorage = config.tokenStorage;
-    this.onQrCode = config.onQrCode; // 回调函数，显示二维码
-    this.onTokenReady = config.onTokenReady; // 回调函数，Token就绪
-    this.preferUrlScheme = config.preferUrlScheme !== false; // 默认优先使用 URL Scheme
+    this.onQrCode = config.onQrCode;
+    this.onTokenReady = config.onTokenReady;
+    this.preferUrlScheme = config.preferUrlScheme !== false;
   }
 
-  /**
-   * 检测当前环境是否支持浏览器/URL Scheme
-   */
   async detectEnvironment() {
-    // 检测是否有 DISPLAY 环境变量（Linux GUI）
     if (process.env.DISPLAY) {
       return { supportsBrowser: true, platform: 'linux-gui' };
     }
 
-    // 检测是否为 macOS
     if (process.platform === 'darwin') {
       return { supportsBrowser: true, platform: 'macos' };
     }
 
-    // 检测是否为 Windows
     if (process.platform === 'win32') {
       return { supportsBrowser: true, platform: 'windows' };
     }
 
-    // 检测是否有 BROWSER 环境变量
     if (process.env.BROWSER) {
       return { supportsBrowser: true, platform: 'custom' };
     }
 
-    // 默认认为不支持浏览器（纯 CLI 环境如 Claude Desktop）
     return { supportsBrowser: false, platform: 'cli' };
   }
 
-  /**
-   * 启动 OAuth 授权流程
-   * 自动检测环境，选择最佳交互方式
-   */
   async startAuthFlow() {
     try {
-      console.log('\n');
-      console.log('╔════════════════════════════════════════════════════════╗');
-      console.log('║  🔴 【重要】首次使用需要完成 OAuth 授权                ║');
-      console.log('║  ⏱️  授权流程约需 1-2 分钟，请耐心等待                 ║');
-      console.log('╚════════════════════════════════════════════════════════╝');
-      console.log('\n');
-
-      // 检测环境
       const env = await this.detectEnvironment();
-      console.log(`检测到环境: ${env.platform} (${env.supportsBrowser ? '支持浏览器' : '纯终端'})`);
-
-      // 1. 获取设备码（根据环境决定是否请求 URL Scheme）
       const useUrlScheme = this.preferUrlScheme && env.supportsBrowser;
       const deviceCodeRes = await this.requestDeviceCode(useUrlScheme);
 
-      console.log('✅ 获取设备码成功');
-      console.log('');
-      
-      // 【柴米记账授权】格式化输出，确保Agent能识别
-      const authMessage = `
-【柴米记账授权】
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-  📱 验证码: ${deviceCodeRes.userCode}
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-请在微信柴米记账小程序中输入此验证码完成授权
-`;
-      console.log(authMessage);
-      
-      // 保存授权状态，支持进程重启后复用
       await this.saveAuthState({
         deviceCode: deviceCodeRes.deviceCode,
         userCode: deviceCodeRes.userCode,
@@ -88,88 +51,42 @@ class OAuthManager {
         status: 'pending'
       });
 
-      // 2. 根据环境选择交互方式
       if (useUrlScheme && deviceCodeRes.urlScheme) {
-        // 方式A：URL Scheme（浏览器环境）
         await this.authorizeWithUrlScheme(deviceCodeRes);
       } else {
-        // 方式B：纯 Device Flow（CLI环境）
         await this.authorizeWithDeviceFlow(deviceCodeRes);
       }
 
-      // 3. 轮询获取 Token
-      console.log('');
-      console.log('⏳ 等待用户授权，请勿关闭窗口...');
-      console.log('   （请在手机微信中完成授权操作）');
-      console.log('   授权完成后会自动继续，无需手动告知');
-      console.log('');
       const token = await this.pollForToken(
         deviceCodeRes.deviceCode,
-        2000  // 固定2秒轮询，更快响应
+        2000
       );
 
-      // 4. 存储 Token
       await this.tokenStorage.save(token);
 
-      console.log('');
-      console.log('╔════════════════════════════════════════════════════════╗');
-      console.log('║  ✅ 授权成功！现在可以开始使用柴米记账 MCP Server      ║');
-      console.log('╚════════════════════════════════════════════════════════╝');
-      console.log('');
-
       if (this.onTokenReady) {
         this.onTokenReady(token);
       }
 
       return token;
     } catch (err) {
-      console.error('\n❌ 授权失败:', err.message);
-      console.log('========================================\n');
       throw err;
     }
   }
 
-  /**
-   * 使用 URL Scheme 方式授权（浏览器环境）
-   * PC端：显示二维码 + 验证码
-   * 手机端：打开跳转链接
-   */
   async authorizeWithUrlScheme(deviceCodeRes) {
-    // 检测是否为移动端环境
     const isMobile = this.detectMobileEnvironment();
 
     if (isMobile) {
-      // 手机端：打开 URL Scheme 跳转链接
-      console.log('\n📱 请在微信中完成授权');
-      console.log('正在尝试自动打开微信...\n');
-
       const url = deviceCodeRes.urlScheme || deviceCodeRes.verificationUriFull;
 
       try {
         await this.openBrowser(url);
-        console.log('✅ 已尝试打开微信');
-        console.log('请在微信中完成授权\n');
       } catch (err) {
-        console.log('⚠️ 无法自动打开微信，请手动操作：');
-        console.log(`1. 复制链接: ${url}`);
-        console.log('2. 在微信中打开该链接\n');
       }
     } else {
-      // PC端：显示二维码 + 验证码
-      console.log('\n💻 请在手机微信中完成授权');
-      console.log('========================================');
-      console.log('');
-
-      // 生成小程序二维码链接
       const qrCodeUrl = `https://mcp.chaihuo.com/auth?deviceCode=${deviceCodeRes.deviceCode}&userCode=${deviceCodeRes.userCode}`;
 
-      // 显示二维码（使用 ASCII 艺术或链接）
-      console.log('请使用微信扫描下方二维码：');
-      console.log('');
-      console.log(`  ${qrCodeUrl}`);
-      console.log('');
-
-      // 如果有二维码回调，显示图形二维码
       if (this.onQrCode) {
         await this.onQrCode({
           userCode: deviceCodeRes.userCode,
@@ -179,81 +96,41 @@ class OAuthManager {
           isPC: true
         });
       }
-
-      console.log('========================================');
-      console.log('');
-      console.log('或者手动输入验证码：');
-      console.log(`  验证码: ${deviceCodeRes.userCode}`);
-      console.log('');
-      console.log('操作步骤：');
-      console.log('1. 打开微信，进入"柴米记账"小程序');
-      console.log('2. 点击"我的" → "🤖 Agent 授权"');
-      console.log(`3. 输入验证码: ${deviceCodeRes.userCode}`);
-      console.log('4. 点击"确认授权"');
-      console.log('');
     }
   }
 
-  /**
-   * 检测是否为移动端环境
-   */
   detectMobileEnvironment() {
-    // 检测 User Agent
     const userAgent = process.env.USER_AGENT || '';
     if (/iPhone|iPad|iPod|Android|Mobile/i.test(userAgent)) {
       return true;
     }
 
-    // 检测是否有移动端特定的环境变量
     if (process.env.TERM_PROGRAM === 'Apple_Terminal' && process.platform === 'darwin') {
-      // macOS 终端，可能是 iTerm2 等，需要进一步判断
-      // 这里假设 PC 端
       return false;
     }
 
-    // 默认认为是 PC 端（保守策略）
-    // 因为 PC 端显示二维码是通用的，手机端打开链接需要确认是移动端
     return false;
   }
 
-  /**
-   * 使用纯 Device Flow 方式授权（CLI环境）
-   */
   async authorizeWithDeviceFlow(deviceCodeRes) {
-    console.log(`\n验证地址: ${deviceCodeRes.verificationUri}\n`);
-
-    // 显示二维码（如果提供了回调）
     if (this.onQrCode) {
       await this.onQrCode({
         userCode: deviceCodeRes.userCode,
         verificationUri: deviceCodeRes.verificationUri,
         deviceCode: deviceCodeRes.deviceCode
       });
-    } else {
-      // 默认输出到控制台
-      console.log('请按以下步骤完成授权：');
-      console.log('1. 打开手机微信，搜索小程序"柴米记账"');
-      console.log('2. 进入"设置" → "授权管理"');
-      console.log(`3. 输入验证码: ${deviceCodeRes.userCode}`);
-      console.log('4. 点击"确认授权"\n');
     }
   }
 
-  /**
-   * 尝试打开浏览器
-   */
   async openBrowser(url) {
     const platform = process.platform;
     let command;
 
     if (platform === 'darwin') {
-      // macOS
       command = `open "${url}"`;
     } else if (platform === 'win32') {
-      // Windows
       command = `start "" "${url}"`;
     } else if (platform === 'linux') {
-      // Linux
       command = `xdg-open "${url}"`;
     } else {
       throw new Error('不支持的平台');
@@ -262,10 +139,6 @@ class OAuthManager {
     await execPromise(command);
   }
 
-  /**
-   * 请求设备码
-   * @param {boolean} useUrlScheme - 是否请求 URL Scheme
-   */
   async requestDeviceCode(useUrlScheme = false) {
     const response = await fetch(this.mcpOAuthUrl, {
       method: 'POST',
@@ -290,17 +163,13 @@ class OAuthManager {
     return result.data;
   }
 
-  /**
-   * 轮询获取 Token
-   */
   async pollForToken(deviceCode, interval) {
-    const maxAttempts = 60; // 最多轮询60次（5分钟）
+    const maxAttempts = 60;
     let attempts = 0;
 
     while (attempts < maxAttempts) {
       attempts++;
 
-      // 等待间隔时间
       await this.delay(interval);
 
       try {
@@ -320,7 +189,6 @@ class OAuthManager {
         const result = await response.json();
 
         if (result.success) {
-          // 获取 Token 成功
           return {
             accessToken: result.data.accessToken,
             refreshToken: result.data.refreshToken,
@@ -330,11 +198,7 @@ class OAuthManager {
           };
         }
 
-        // 处理错误
         if (result.error === 'authorization_pending') {
-          // 仍在等待授权，继续轮询
-          const elapsedSeconds = attempts * (interval / 1000);
-          process.stdout.write(`\r   等待中... ${elapsedSeconds}秒（请在小程完成授权）`);
           continue;
         }
 
@@ -351,17 +215,12 @@ class OAuthManager {
         if (err.message.includes('expired') || err.message.includes('invalid')) {
           throw err;
         }
-        // 网络错误，继续轮询
-        console.warn(`轮询出错: ${err.message}，继续尝试...`);
       }
     }
 
     throw new Error('授权超时，请重新尝试');
   }
 
-  /**
-   * 刷新 Access Token
-   */
   async refreshToken() {
     const currentToken = await this.tokenStorage.load();
 
@@ -392,7 +251,6 @@ class OAuthManager {
         throw new Error(`刷新 Token 失败: ${result.error}`);
       }
 
-      // 更新 Token
       const newToken = {
         accessToken: result.data.accessToken,
         refreshToken: result.data.refreshToken,
@@ -403,19 +261,12 @@ class OAuthManager {
 
       await this.tokenStorage.save(newToken);
 
-      console.log('✅ Token 刷新成功');
-
       return newToken;
     } catch (err) {
-      console.error('刷新 Token 失败:', err.message);
       throw err;
     }
   }
 
-  /**
-   * 获取有效的 Access Token
-   * 如果即将过期，自动刷新
-   */
   async getValidToken() {
     const token = await this.tokenStorage.load();
 
@@ -423,53 +274,36 @@ class OAuthManager {
       throw new Error('没有存储的 Token，请先授权');
     }
 
-    // 检查是否即将过期（提前5分钟刷新）
-    const refreshThreshold = 5 * 60 * 1000; // 5分钟
+    const refreshThreshold = 5 * 60 * 1000;
     if (Date.now() + refreshThreshold > token.expiresAt) {
-      console.log('Token 即将过期，自动刷新...');
       return await this.refreshToken();
     }
 
     return token;
   }
 
-  /**
-   * 延迟函数
-   */
   delay(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
   }
 
-  /**
-   * 保存授权状态到文件
-   * 支持进程重启后复用验证码
-   */
   async saveAuthState(state) {
     try {
       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 }
       );
     } catch (err) {
-      // 保存失败不影响主流程
-      console.warn('保存授权状态失败:', err.message);
     }
   }
 
-  /**
-   * 加载授权状态
-   * 用于进程重启后恢复授权流程
-   */
   async loadAuthState() {
     try {
       const fs = require('fs').promises;
@@ -480,17 +314,12 @@ class OAuthManager {
       return JSON.parse(data);
     } catch (err) {
       if (err.code === 'ENOENT') {
-        return null; // 文件不存在
+        return null;
       }
-      console.warn('加载授权状态失败:', err.message);
       return null;
     }
   }
 
-  /**
-   * 清除授权状态
-   * 授权成功或过期后清理
-   */
   async clearAuthState() {
     try {
       const fs = require('fs').promises;
@@ -498,24 +327,15 @@ class OAuthManager {
       const stateFile = path.join(require('os').homedir(), '.mcporter', 'auth-state.json');
       await fs.unlink(stateFile);
     } catch (err) {
-      // 文件不存在或其他错误，忽略
     }
   }
 
-  /**
-   * 检查授权状态是否过期
-   * 默认10分钟有效期
-   */
   isAuthStateExpired(state, maxAge = 10 * 60 * 1000) {
     if (!state || !state.timestamp) return true;
     return Date.now() - state.timestamp > maxAge;
   }
 }
 
-/**
- * Token 存储接口（基类）
- * 子类需要实现 save 和 load 方法
- */
 class TokenStorage {
   async save(token) {
     throw new Error('TokenStorage.save 必须被子类实现');
@@ -530,9 +350,6 @@ class TokenStorage {
   }
 }
 
-/**
- * 文件存储实现
- */
 class FileTokenStorage extends TokenStorage {
   constructor(filePath) {
     super();
@@ -547,7 +364,7 @@ class FileTokenStorage extends TokenStorage {
     await this.fs.writeFile(
       this.filePath,
       JSON.stringify(token, null, 2),
-      { mode: 0o600 } // 仅所有者可读写
+      { mode: 0o600 }
     );
   }
 
@@ -557,7 +374,7 @@ class FileTokenStorage extends TokenStorage {
       return JSON.parse(data);
     } catch (err) {
       if (err.code === 'ENOENT') {
-        return null; // 文件不存在
+        return null;
       }
       throw err;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chaimi-bookkeeping-mcp",
-  "version": "2.3.6",
+  "version": "2.3.9",
   "description": "柴米记账 MCP Server - 支持 Claude、Cursor、OpenClaw、WorkBuddy 等 AI 工具直接记账",
   "main": "server.js",
   "bin": {

package/server.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 /**
  * 柴米记账 MCP Server (Node.js 版本)
+ * 适配微信云函数 mcpHub
  * 支持 Claude Desktop、Cursor、WorkBuddy、OpenClaw
  */
 
@@ -17,20 +18,51 @@ const {
   CallToolRequestSchema,
   ListToolsRequestSchema,
 } = require('@modelcontextprotocol/sdk/types.js');
-const fs = require('fs');
 const path = require('path');
+const os = require('os');
+const fs = require('fs');
 
-// 读取 package.json 获取版本号
+// 读取 package.json 获取版本
 const packageJson = JSON.parse(fs.readFileSync(path.join(__dirname, 'package.json'), 'utf8'));
 const MCP_VERSION = packageJson.version;
 
-// 配置
-const SCF_URL = process.env.SCF_URL || 'https://1412172089-4wbwsop8pe.ap-shanghai.tencentscf.com';
+// 导入 OAuth 模块
+const { OAuthManager, FileTokenStorage } = require('./oauth.js');
+
+// 配置 - 微信云函数
+const MCP_HUB_URL = process.env.MCP_HUB_URL || 'https://cloud1-2gfe5jhjef06b85d-1412172089.ap-shanghai.app.tcloudbase.com/mcpHub-mcp';
+const MCP_PROMPT_URL = process.env.MCP_PROMPT_URL || 'https://cloud1-2gfe5jhjef06b85d-1412172089.ap-shanghai.app.tcloudbase.com/mcpPrompt';
+const MCP_OAUTH_URL = process.env.MCP_OAUTH_URL || 'https://cloud1-2gfe5jhjef06b85d-1412172089.ap-shanghai.app.tcloudbase.com/mcpOAuth';
+
+// Token 缓存
+let cachedToken = null;
+let tokenExpireTime = 0;
+
+// OAuth 管理器实例
+let oauthManager = null;
+
+// 初始化 OAuth 管理器
+function initOAuthManager() {
+  const tokenStorage = new FileTokenStorage(
+    path.join(os.homedir(), '.mcporter', 'oauth-token.json')
+  );
+
+  oauthManager = new OAuthManager({
+    mcpOAuthUrl: MCP_OAUTH_URL,
+    tokenStorage: tokenStorage,
+    onQrCode: (qrData) => {
+    },
+    onTokenReady: (token) => {
+    }
+  });
+
+  return oauthManager;
+}
 
 // 创建 MCP Server
 const server = new Server(
   {
-    name: 'chaihuo-mcp-server',
+    name: 'chaimi-bookkeeping-mcp',
     version: MCP_VERSION,
   },
   {
@@ -46,17 +78,19 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
     tools: [
       {
         name: 'save_expense',
-        description: '保存单商品消费记录（AI文字记账）',
+        description: '保存单商品消费记录（AI文字记账）。只需提供商品名称和金额，其他参数自动填充。示例：name="午餐", amount=35',
         inputSchema: {
           type: 'object',
           properties: {
-            name: { type: 'string', description: '商品名称' },
-            amount: { type: 'number', description: '金额' },
-            category: { type: 'string', description: '分类（如：餐饮、食品、交通）' },
-            store: { type: 'string', description: '商家名称' },
+            name: { type: 'string', description: '商品名称（必填）' },
+            amount: { type: 'number', description: '金额（必填）' },
+            category: { type: 'string', description: '分类（可选，如：餐饮、食品、交通）' },
+            store: { type: 'string', description: '商家名称（可选）' },
+            note: { type: 'string', description: '备注（可选）' },
             agentType: { type: 'string', description: '【推荐自动填充】Agent类型，如：claude-desktop、cursor、openclaw、workbuddy、trae' },
             apiProvider: { type: 'string', description: '【推荐自动填充】AI服务提供商，如：anthropic、openai、doubao、aliyun' },
             rawInput: { type: 'string', description: '【推荐自动填充】用户的原始输入内容，用于记录用户原始请求' },
+            mcp_version: { type: 'string', description: 'MCP Server 版本号（自动填充）' },
           },
           required: ['name', 'amount'],
         },
@@ -75,28 +109,29 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             actualAmount: { type: 'number', description: '实付金额' },
             paymentMethod: { type: 'string', description: '支付方式' },
             receiptNo: { type: 'string', description: '小票编号' },
-            agentType: { type: 'string', description: '【推荐自动填充】Agent类型，如：claude-desktop、cursor、openclaw、workbuddy、trae' },
-            apiProvider: { type: 'string', description: '【推荐自动填充】AI服务提供商，如：anthropic、openai、doubao、aliyun' },
-            rawInput: { type: 'string', description: '【推荐自动填充】用户的原始输入内容，用于记录用户原始请求' },
             items: {
               type: 'array',
-              description: '商品列表',
+              description: '商品列表（必须是数组格式，如：[{"name":"苹果","amount":5.5,"price":5.5,"quantity":1}]，不要传JSON字符串）',
               items: {
                 type: 'object',
                 properties: {
                   name: { type: 'string', description: '商品名称' },
                   originalName: { type: 'string', description: '原始商品名称' },
                   price: { type: 'number', description: '单价' },
-                  quantity: { type: 'string', description: '数量' },
+                  quantity: { type: 'number', description: '数量' },
                   unit: { type: 'string', description: '单位' },
                   amount: { type: 'number', description: '金额' },
                   weight: { type: 'string', description: '重量' },
                   marketPrice: { type: 'string', description: '市场单价' },
                   category: { type: 'string', description: '分类' },
                 },
-                required: ['name', 'amount'],
+                required: ['name', 'amount', 'price', 'quantity'],
               },
             },
+            agentType: { type: 'string', description: '【推荐自动填充】Agent类型，如：claude-desktop、cursor、openclaw、workbuddy、trae' },
+            apiProvider: { type: 'string', description: '【推荐自动填充】AI服务提供商，如：anthropic、openai、doubao、aliyun' },
+            rawInput: { type: 'string', description: '【推荐自动填充】用户的原始输入内容，用于记录用户原始请求' },
+            mcp_version: { type: 'string', description: 'MCP Server 版本号（自动填充）' },
           },
           required: ['store', 'items'],
         },
@@ -109,9 +144,6 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
           properties: {
             limit: { type: 'number', description: '返回数量限制', default: 10 },
             source: { type: 'string', description: '来源筛选' },
-            agentType: { type: 'string', description: '【推荐自动填充】Agent类型，如：claude-desktop、cursor、openclaw、workbuddy、trae' },
-            apiProvider: { type: 'string', description: '【推荐自动填充】AI服务提供商，如：anthropic、openai、doubao、aliyun' },
-            rawInput: { type: 'string', description: '【推荐自动填充】用户的原始输入内容，用于记录用户原始请求' },
           },
         },
       },
@@ -122,9 +154,6 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
           type: 'object',
           properties: {
             limit: { type: 'number', description: '返回数量限制', default: 5 },
-            agentType: { type: 'string', description: '【推荐自动填充】Agent类型，如：claude-desktop、cursor、openclaw、workbuddy、trae' },
-            apiProvider: { type: 'string', description: '【推荐自动填充】AI服务提供商，如：anthropic、openai、doubao、aliyun' },
-            rawInput: { type: 'string', description: '【推荐自动填充】用户的原始输入内容，用于记录用户原始请求' },
           },
         },
       },
@@ -136,72 +165,289 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
           properties: {
             yearMonth: { type: 'string', description: '年月（如：2026-03）' },
             type: { type: 'string', description: '统计类型：item/receipt/category' },
+          },
+          required: ['yearMonth'],
+        },
+      },
+      {
+        name: 'save_income',
+        description: '保存收入记录（工资、奖金、红包等）',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            name: { type: 'string', description: '收入来源（如：工资、奖金、红包）' },
+            amount: { type: 'number', description: '收入金额' },
+            category: { type: 'string', description: '收入分类（如：工资、奖金、投资）' },
+            store: { type: 'string', description: '付款方（如：公司名称）' },
+            note: { type: 'string', description: '备注' },
             agentType: { type: 'string', description: '【推荐自动填充】Agent类型，如：claude-desktop、cursor、openclaw、workbuddy、trae' },
             apiProvider: { type: 'string', description: '【推荐自动填充】AI服务提供商，如：anthropic、openai、doubao、aliyun' },
             rawInput: { type: 'string', description: '【推荐自动填充】用户的原始输入内容，用于记录用户原始请求' },
+            mcp_version: { type: 'string', description: 'MCP Server 版本号（自动填充）' },
           },
-          required: ['yearMonth'],
+          required: ['name', 'amount'],
         },
       },
     ],
   };
 });
 
+// 工具名称映射：MCP Tool -> mcpHub Tool
+const toolMapping = {
+  'save_expense': 'addExpense',
+  'save_receipt': 'addReceipt',
+  'save_income': 'addIncome',
+  'get_expenses': 'getExpenses',
+  'get_receipt_list': 'getExpenses',
+  'get_statistics': 'getStatistics',
+};
+
+// 获取或刷新 Token（OAuth 2.0 Device Flow）
+const TOKEN_REFRESH_INTERVAL = 2 * 60 * 60 * 1000;
+let lastRefreshTime = 0;
+
+async function getToken() {
+  if (cachedToken && tokenExpireTime > Date.now() + 5 * 60 * 1000) {
+    if (Date.now() - lastRefreshTime < TOKEN_REFRESH_INTERVAL) {
+      return cachedToken;
+    }
+  }
+
+  if (!oauthManager) {
+    throw new Error('OAuth 管理器未初始化，请检查 MCP_OAUTH_URL 配置');
+  }
+
+  try {
+    const oauthToken = await oauthManager.getValidToken();
+    cachedToken = oauthToken.accessToken;
+    tokenExpireTime = oauthToken.expiresAt;
+    lastRefreshTime = Date.now();
+    await oauthManager.clearAuthState();
+    return cachedToken;
+  } catch (err) {
+    const authState = await oauthManager.loadAuthState();
+    if (authState && !oauthManager.isAuthStateExpired(authState)) {
+      throw new Error(`授权进行中，请使用验证码 ${authState.userCode} 完成授权`);
+    }
+    
+    const newToken = await oauthManager.startAuthFlow();
+    cachedToken = newToken.accessToken;
+    tokenExpireTime = newToken.expiresAt;
+    lastRefreshTime = Date.now();
+    await oauthManager.clearAuthState();
+    return cachedToken;
+  }
+}
+
+// 调用 mcpPrompt 云函数（获取 Prompt 或校验数据）
+async function callMcpPrompt(tool, params, token) {
+  const response = await fetch(MCP_PROMPT_URL, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${token}`,
+    },
+    body: JSON.stringify({
+      tool: tool,
+      params: params,
+    }),
+  });
+
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`mcpPrompt 调用失败: ${errorText}`);
+  }
+
+  return await response.json();
+}
+
+// 调用 mcpHub 云函数
+async function callMcpHub(tool, params, token) {
+  const response = await fetch(MCP_HUB_URL, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${token}`,
+    },
+    body: JSON.stringify({
+      tool: tool,
+      params: params,
+    }),
+  });
+
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`mcpHub 调用失败: ${errorText}`);
+  }
+
+  return await response.json();
+}
+
 // 工具调用处理
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
   const { name, arguments: args } = request.params;
 
-  // 调试日志
-  console.error('收到工具调用请求:', name);
-  console.error('原始参数:', JSON.stringify(args, null, 2));
+  const agentTypeFromEnv = process.env.AGENT_TYPE || process.env.MCP_AGENT_TYPE || '';
+  const apiProviderFromEnv = process.env.API_PROVIDER || process.env.MCP_API_PROVIDER || '';
 
-  try {
-    // 获取 Token（这里需要实现 Token 生成逻辑）
-    const token = await generateToken();
+  if (!args.agentType && agentTypeFromEnv) {
+    args.agentType = agentTypeFromEnv;
+  }
+  if (!args.apiProvider && apiProviderFromEnv) {
+    args.apiProvider = apiProviderFromEnv;
+  }
 
-    // SCF 使用下划线命名，直接传递工具名
-    const action = name;
+  try {
+    const token = await getToken();
 
-    // 处理参数 - 将字符串格式的 items 转换为数组
     const processedArgs = { ...args };
     if (processedArgs.items && typeof processedArgs.items === 'string') {
       try {
         processedArgs.items = JSON.parse(processedArgs.items);
-        console.error('items 解析成功:', processedArgs.items);
       } catch (e) {
-        // 如果解析失败，保持原样
-        console.error('解析 items 失败:', e);
       }
     }
 
-    console.error('处理后参数:', JSON.stringify(processedArgs, null, 2));
+    let result;
+    let userMessage;
 
-    // 调用 SCF
-    const response = await fetch(SCF_URL, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'Authorization': `Bearer ${token}`,
-      },
-      body: JSON.stringify({
-        action: action,
-        data: processedArgs,
-      }),
-    });
-
-    const result = await response.json();
-
-    // 检查是否传递了agentType和apiProvider参数，如果没有则添加提示
-    let responseText = JSON.stringify(result, null, 2);
-    if (!processedArgs.agentType || !processedArgs.apiProvider) {
-      responseText += '\n\n💡 提示：传递agentType和apiProvider参数可解锁小程序记录来源统计功能，示例：agentType="openclaw", apiProvider="doubao"';
+    switch (name) {
+      case 'save_expense': {
+        const validationResult = await callMcpPrompt(
+          'validateResult',
+          {
+            data: processedArgs,
+            type: 'parseText'
+          },
+          token
+        );
+        
+        if (validationResult.success && !validationResult.data.valid) {
+          const fillResult = await callMcpPrompt(
+            'fillDefaults',
+            {
+              data: processedArgs,
+              type: 'parseText'
+            },
+            token
+          );
+          
+          if (fillResult.success) {
+            processedArgs = fillResult.data;
+          }
+        }
+        
+        const mcpParams = convertParams('save_expense', processedArgs);
+        result = await callMcpHub('addExpense', mcpParams, token);
+        
+        if (result.success) {
+          const displayName = processedArgs.name || '未知商品';
+          const displayAmount = processedArgs.amount || 0;
+          const displayCategory = processedArgs.category || '其他';
+          const displayStore = processedArgs.store || '-';
+          userMessage = `✅ 记账成功\n\n| 商品 | 金额 | 分类 | 商家 |\n|------|------|------|------|\n| ${displayName} | ${displayAmount}元 | ${displayCategory} | ${displayStore} |\n\n已保存到你的柴米记账小程序数据库。`;
+          
+          if (!processedArgs.agentType || !processedArgs.apiProvider) {
+            userMessage += '\n\n💡 提示：传递agentType和apiProvider参数可解锁小程序记录来源统计功能，示例：agentType="openclaw", apiProvider="doubao"';
+          }
+        }
+        break;
+      }
+
+      case 'save_receipt': {
+        const validationResult = await callMcpPrompt(
+          'validateResult',
+          {
+            data: processedArgs,
+            type: 'parseReceipt'
+          },
+          token
+        );
+        
+        if (validationResult.success && !validationResult.data.valid) {
+          const fillResult = await callMcpPrompt(
+            'fillDefaults',
+            {
+              data: processedArgs,
+              type: 'parseReceipt'
+            },
+            token
+          );
+          
+          if (fillResult.success) {
+            processedArgs = fillResult.data;
+          }
+        }
+        
+        const mcpParams = convertParams('save_receipt', processedArgs);
+        result = await callMcpHub('addReceipt', mcpParams, token);
+        
+        if (result.success) {
+          const totalAmount = processedArgs.totalAmount || processedArgs.items?.reduce((sum, item) => sum + (item.amount || 0), 0) || 0;
+          const itemsList = processedArgs.items?.map(item => `• ${item.name || '未知商品'} - ${item.amount || 0}元`).join('\n') || '暂无商品明细';
+          const storeName = processedArgs.store || '-';
+          const category = processedArgs.items?.[0]?.category || '其他';
+          userMessage = `✅ 小票记录成功\n\n| 项目 | 内容 |\n|------|------|\n| 商家 | ${storeName} |\n| 金额 | ${totalAmount}元 |\n| 分类 | ${category} |\n\n商品明细：\n${itemsList}\n\n已保存到你的柴米记账小程序数据库。`;
+          
+          if (!processedArgs.agentType || !processedArgs.apiProvider) {
+            userMessage += '\n\n💡 提示：传递agentType和apiProvider参数可解锁小程序记录来源统计功能，示例：agentType="openclaw", apiProvider="doubao"';
+          }
+        }
+        break;
+      }
+
+      case 'get_expenses':
+      case 'get_receipt_list': {
+        const toolName = toolMapping[name];
+        const mcpParams = convertParams(name, processedArgs);
+        result = await callMcpHub(toolName, mcpParams, token);
+        
+        if (result.success) {
+          userMessage = `📊 消费记录查询成功\n共找到 ${result.data?.length || 0} 条记录`;
+        }
+        break;
+      }
+
+      case 'get_statistics': {
+        const toolName = toolMapping[name];
+        const mcpParams = convertParams(name, processedArgs);
+        result = await callMcpHub(toolName, mcpParams, token);
+
+        if (result.success) {
+          userMessage = `📈 统计查询成功`;
+        }
+        break;
+      }
+
+      case 'save_income': {
+        const mcpParams = convertParams('save_income', processedArgs);
+        result = await callMcpHub('addIncome', mcpParams, token);
+
+        if (result.success) {
+          const displayName = processedArgs.name || '未知来源';
+          const displayAmount = processedArgs.amount || 0;
+          const displayCategory = processedArgs.category || '其他';
+          const displayStore = processedArgs.store || '-';
+          userMessage = `✅ 收入记录成功\n\n| 来源 | 金额 | 分类 | 付款方 |\n|------|------|------|--------|\n| ${displayName} | ${displayAmount}元 | ${displayCategory} | ${displayStore} |`;
+        }
+        break;
+      }
+
+      default:
+        throw new Error(`未知工具: ${name}`);
+    }
+
+    if (!result.success) {
+      userMessage = `❌ 操作失败：${result.error || '未知错误'}`;
     }
 
+    userMessage += `\n\n---\n📦 柴米记账 MCP v${MCP_VERSION}`;
+
     return {
       content: [
         {
           type: 'text',
-          text: responseText,
+          text: userMessage,
         },
       ],
     };
@@ -218,44 +464,202 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
   }
 });
 
-// 生成 JWT Token
-async function generateToken() {
-  const JWT_SECRET = process.env.JWT_SECRET;
-  const MCP_OPENID = process.env.MCP_OPENID;
-  
-  if (!JWT_SECRET) {
-    throw new Error('JWT_SECRET 环境变量未设置');
-  }
+function sanitizeString(str, maxLength = 200) {
+  if (!str || typeof str !== 'string') return '';
+  return str.replace(/<[^>]*>/g, '').substring(0, maxLength);
+}
+
+function validateAmount(amount) {
+  const num = parseFloat(amount);
+  return isNaN(num) || num < 0 ? 0 : num;
+}
+
+function validateQuantity(quantity) {
+  const num = parseFloat(quantity);
+  return isNaN(num) || num <= 0 ? 1 : num;
+}
+
+function extractWeightInGrams(weightStr) {
+  if (!weightStr || typeof weightStr !== 'string') return 0;
   
-  if (!MCP_OPENID) {
-    throw new Error('MCP_OPENID 环境变量未设置，请从小程序获取用户Token');
-  }
+  const match = weightStr.match(/(\d+\.?\d*)\s*(g|kg|斤|克|千克)/i);
+  if (!match) return 0;
   
-  // 使用 crypto 生成 JWT
-  const crypto = require('crypto');
+  const value = parseFloat(match[1]);
+  const unit = match[2].toLowerCase();
   
-  const header = { alg: 'HS256', typ: 'JWT' };
-  const payload = {
-    openid: MCP_OPENID,  // 使用固定的用户 openid
-    iat: Math.floor(Date.now() / 1000),
-    exp: Math.floor(Date.now() / 1000) + 86400
-  };
+  switch (unit) {
+    case 'g':
+    case '克':
+      return value;
+    case 'kg':
+    case '千克':
+      return value * 1000;
+    case '斤':
+      return value * 500;
+    default:
+      return value;
+  }
+}
+
+function calculateMarketPrice(amount, weightStr) {
+  const amountNum = parseFloat(amount);
+  const weightInGrams = extractWeightInGrams(weightStr);
   
-  const h = Buffer.from(JSON.stringify(header)).toString('base64url');
-  const p = Buffer.from(JSON.stringify(payload)).toString('base64url');
-  const sig = crypto
-    .createHmac('sha256', JWT_SECRET)
-    .update(h + '.' + p)
-    .digest('base64url');
+  if (isNaN(amountNum) || amountNum <= 0 || weightInGrams <= 0) {
+    return '';
+  }
   
-  return `${h}.${p}.${sig}`;
+  const pricePer500g = (amountNum / weightInGrams) * 500;
+  return `${pricePer500g.toFixed(2)}元/500g`;
+}
+
+function convertParams(toolName, args) {
+  switch (toolName) {
+    case 'save_expense': {
+      if (!args.name || typeof args.name !== 'string' || args.name.trim() === '') {
+        throw new Error('缺少必填参数：name（商品名称）');
+      }
+      if (args.amount === undefined || args.amount === null) {
+        throw new Error('缺少必填参数：amount（金额）');
+      }
+      
+      const name = sanitizeString(args.name, 100);
+      const amount = validateAmount(args.amount);
+      
+      return {
+        name: name,
+        originalName: name,
+        amount: amount,
+        price: amount,
+        quantity: 1,
+        category: sanitizeString(args.category, 50) || '其他',
+        store: sanitizeString(args.store, 100) || '',
+        transactionType: 'expense',
+        unit: '',
+        weight: '',
+        marketPrice: '',
+        note: sanitizeString(args.note, 500) || '',
+        rawInput: sanitizeString(args.rawInput, 1000) || '',
+        agentType: args.agentType || '',
+        apiProvider: args.apiProvider || '',
+        mcp_version: args.mcp_version || MCP_VERSION,
+        source: 'mcp_txt_expense',
+      };
+    }
+
+    case 'save_receipt': {
+      let items = args.items;
+      if (typeof items === 'string') {
+        try {
+          items = JSON.parse(items);
+        } catch (e) {
+          throw new Error('items 参数格式错误：必须是数组或 JSON 数组字符串');
+        }
+      }
+      if (!Array.isArray(items)) {
+        throw new Error('items 参数必须是数组');
+      }
+      
+      return {
+        items: items.map((item, index) => {
+          const weight = sanitizeString(item.weight, 50);
+          const amount = validateAmount(item.amount);
+          const marketPrice = sanitizeString(item.marketPrice, 50) || calculateMarketPrice(amount, weight);
+          
+          return {
+            itemIndex: index,
+            name: sanitizeString(item.name, 100),
+            originalName: sanitizeString(item.originalName, 200) || sanitizeString(item.name, 100),
+            amount: amount,
+            category: sanitizeString(item.category, 50) || '其他',
+            subCategory: sanitizeString(item.subCategory, 50) || '',
+            transactionType: item.transactionType || 'expense',
+            price: validateAmount(item.price),
+            quantity: item.quantity ? String(item.quantity).substring(0, 20) : '1',
+            unit: sanitizeString(item.unit, 20),
+            weight: weight,
+            marketPrice: marketPrice,
+            note: sanitizeString(item.note, 500),
+          };
+        }),
+        store: sanitizeString(args.store, 100),
+        receiptNo: sanitizeString(args.receiptNo, 50),
+        totalAmount: validateAmount(args.totalAmount),
+        originalAmount: validateAmount(args.originalAmount),
+        discountAmount: validateAmount(args.discountAmount),
+        actualAmount: validateAmount(args.actualAmount),
+        paymentMethod: sanitizeString(args.paymentMethod, 50),
+        memberCardNo: sanitizeString(args.memberCardNo, 50),
+        currentPoints: parseInt(args.currentPoints) || 0,
+        totalPoints: parseInt(args.totalPoints) || 0,
+        rawInput: sanitizeString(args.rawInput, 2000),
+        agentType: args.agentType || '',
+        apiProvider: args.apiProvider || '',
+        mcp_version: args.mcp_version || MCP_VERSION,
+        source: 'mcp_receipt',
+      };
+    }
+
+    case 'get_expenses':
+      return {
+        limit: Math.min(parseInt(args.limit) || 10, 100),
+        source: args.source,
+      };
+
+    case 'get_statistics':
+      return {
+        startDate: args.yearMonth ? `${args.yearMonth}-01` : undefined,
+        endDate: args.yearMonth ? getMonthEndDate(args.yearMonth) : undefined,
+        type: args.type,
+      };
+
+    case 'save_income':
+      return {
+        name: sanitizeString(args.name, 100),
+        amount: validateAmount(args.amount),
+        category: sanitizeString(args.category, 50) || '其他',
+        store: sanitizeString(args.store, 100),
+        note: sanitizeString(args.note, 500),
+        transactionType: 'income',
+        rawInput: sanitizeString(args.rawInput, 1000),
+        agentType: args.agentType || '',
+        apiProvider: args.apiProvider || '',
+        mcp_version: args.mcp_version || MCP_VERSION,
+        source: 'mcp_txt_income',
+      };
+
+    default:
+      return args;
+  }
+}
+
+function getMonthEndDate(yearMonth) {
+  const [year, month] = yearMonth.split('-').map(Number);
+  const lastDay = new Date(year, month, 0).getDate();
+  return `${yearMonth}-${lastDay}`;
 }
 
-// 启动服务器
 async function main() {
+  initOAuthManager();
+
+  try {
+    const existingToken = await oauthManager.tokenStorage.load();
+    if (existingToken) {
+      const validToken = await oauthManager.getValidToken();
+      cachedToken = validToken.accessToken;
+      tokenExpireTime = validToken.expiresAt;
+    } else {
+      const newToken = await oauthManager.startAuthFlow();
+      cachedToken = newToken.accessToken;
+      tokenExpireTime = newToken.expiresAt;
+    }
+  } catch (err) {
+    throw err;
+  }
+
   const transport = new StdioServerTransport();
   await server.connect(transport);
-  console.error('柴米记账 MCP Server 已启动');
 }
 
-main().catch(console.error);
+main().catch(() => {});

package/test-mcp.sh

@@ -0,0 +1,26 @@
+#!/bin/bash
+
+# MCP Server 本地测试脚本
+
+echo "=== 柴米记账 MCP Server 本地测试 ==="
+echo ""
+
+# 设置环境变量（测试环境）
+export MCP_HUB_URL="https://chaihuo-xxx.ap-shanghai.app.tcloudbase.com/mcpHub-mcp"
+export MCP_PROMPT_URL="https://chaihuo-xxx.ap-shanghai.app.tcloudbase.com/mcpPrompt"
+export MCP_OAUTH_URL="https://chaihuo-xxx.ap-shanghai.app.tcloudbase.com/mcpOAuth"
+export AGENT_TYPE="test"
+export API_PROVIDER="test"
+
+echo "环境变量设置："
+echo "  MCP_HUB_URL: $MCP_HUB_URL"
+echo "  AGENT_TYPE: $AGENT_TYPE"
+echo "  API_PROVIDER: $API_PROVIDER"
+echo ""
+
+# 测试 MCP Server 启动
+echo "=== 测试 MCP Server 启动 ==="
+echo "按 Ctrl+C 停止测试"
+echo ""
+
+node server.js