chaimi-bookkeeping-mcp 2.3.6 → 2.3.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chaimi-bookkeeping-mcp",
-  "version": "2.3.6",
+  "version": "2.3.7",
   "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,60 @@ 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;
+console.log('柴米记账 MCP Server 版本:', MCP_VERSION);
+
+// 导入 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) => {
+      // 显示授权信息
+      console.log('\n========================================');
+      console.log('🔐 请完成授权');
+      console.log('========================================');
+      console.log(`验证码: ${qrData.userCode}`);
+      console.log(`验证地址: ${qrData.verificationUri}`);
+      console.log('========================================\n');
+    },
+    onTokenReady: (token) => {
+      console.log('✅ Token 已就绪，可以开始使用');
+    }
+  });
 
-// 配置
-const SCF_URL = process.env.SCF_URL || 'https://1412172089-4wbwsop8pe.ap-shanghai.tencentscf.com';
+  return oauthManager;
+}
 
 // 创建 MCP Server
 const server = new Server(
   {
-    name: 'chaihuo-mcp-server',
+    name: 'chaimi-bookkeeping-mcp',
     version: MCP_VERSION,
   },
   {
@@ -44,19 +85,42 @@ const server = new Server(
 server.setRequestHandler(ListToolsRequestSchema, async () => {
   return {
     tools: [
+      /*
+      {
+        name: 'quick_book',
+        description: '【推荐首选】极简快捷记账 - 自动识别支出/收入，智能匹配分类。仅需 name 和 amount 两个参数，其他自动补全。输入如："午餐 30 元"、"工资 8000 元"、"木屋烧烤 35 元"',
+        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: ['name', 'amount'],
+        },
+      },
+      */
       {
         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 +139,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 +174,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 +184,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,76 +195,427 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
           properties: {
             yearMonth: { type: 'string', description: '年月（如：2026-03）' },
             type: { type: 'string', description: '统计类型：item/receipt/category' },
-            agentType: { type: 'string', description: '【推荐自动填充】Agent类型，如：claude-desktop、cursor、openclaw、workbuddy、trae' },
-            apiProvider: { type: 'string', description: '【推荐自动填充】AI服务提供商，如：anthropic、openai、doubao、aliyun' },
-            rawInput: { type: 'string', description: '【推荐自动填充】用户的原始输入内容，用于记录用户原始请求' },
           },
           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 类型（如：workbuddy、claude、cursor）' },
+            apiProvider: { type: 'string', description: 'AI 提供商' },
+            rawInput: { type: 'string', description: '用户原始输入' },
+            mcp_version: { type: 'string', description: 'MCP Server 版本号（自动填充）' },
+          },
+          required: ['name', 'amount'],
+        },
+      },
     ],
   };
 });
 
+// 工具名称映射：SCF action -> mcpHub tool
+const toolMapping = {
+  'quick_book': 'addExpense',  // quick_book 内部会判断支出/收入
+  '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）
+// 自动刷新周期：2小时（测试用，生产环境建议24小时）
+const TOKEN_REFRESH_INTERVAL = 2 * 60 * 60 * 1000; // 2小时
+let lastRefreshTime = 0;
+
+async function getToken() {
+  // 检查缓存的 Token 是否有效（提前5分钟过期）
+  if (cachedToken && tokenExpireTime > Date.now() + 5 * 60 * 1000) {
+    // 检查是否需要主动刷新（超过24小时）
+    if (Date.now() - lastRefreshTime < TOKEN_REFRESH_INTERVAL) {
+      return cachedToken;
+    }
+    // 超过2小时，尝试刷新
+    console.log('Token 超过2小时，尝试自动刷新...');
+  } else if (cachedToken && tokenExpireTime <= Date.now() + 5 * 60 * 1000) {
+    // Token 已过期，添加友好提示
+    console.log('🔐 Token 已过期，需要重新授权');
+    console.log('请使用 mcporter 调用 柴米记账.save_expense() 开始授权');
+  }
+
+  // 使用 OAuth 获取有效 Token
+  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) {
+    // OAuth Token 无效，检查是否有未完成的授权
+    console.log('🔐 Token 已过期，需要重新授权');
+    console.log('请使用 mcporter 调用 柴米记账.save_expense() 开始授权');
+    console.log('OAuth Token 无效，检查授权状态...');
+    
+    // 检查是否有未完成的授权
+    const authState = await oauthManager.loadAuthState();
+    if (authState && !oauthManager.isAuthStateExpired(authState)) {
+      console.log(`检测到未完成的授权，验证码: ${authState.userCode}`);
+      console.log('请在微信柴米记账小程序中输入此验证码完成授权');
+      console.log('授权完成后，请重新调用工具');
+      throw new Error(`授权进行中，请使用验证码 ${authState.userCode} 完成授权`);
+    }
+    
+    // 没有未完成的授权，启动新的授权流程
+    console.log('启动新的授权流程...');
+    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 fs = require('fs');
 
-  try {
-    // 获取 Token（这里需要实现 Token 生成逻辑）
-    const token = await generateToken();
+  // 从环境变量获取 agentType 和 apiProvider
+  const agentTypeFromEnv = process.env.AGENT_TYPE || process.env.MCP_AGENT_TYPE || '';
+  const apiProviderFromEnv = process.env.API_PROVIDER || process.env.MCP_API_PROVIDER || '';
+
+  // 如果参数中没有，使用环境变量的值
+  if (!args.agentType && agentTypeFromEnv) {
+    args.agentType = agentTypeFromEnv;
+  }
+  if (!args.apiProvider && apiProviderFromEnv) {
+    args.apiProvider = apiProviderFromEnv;
+  }
 
-    // SCF 使用下划线命名，直接传递工具名
-    const action = name;
+  const logMsg = `
+[${new Date().toISOString()}] MCP 工具被调用
+工具名称: ${name}
+参数: ${JSON.stringify(args, null, 2)}
+环境变量 AGENT_TYPE: ${agentTypeFromEnv || '(未设置)'}
+环境变量 API_PROVIDER: ${apiProviderFromEnv || '(未设置)'}
+`;
+  fs.appendFileSync('/tmp/mcp-debug.log', logMsg);
+  console.error(logMsg);
 
-    // 处理参数 - 将字符串格式的 items 转换为数组
+  try {
+    // 获取 Token
+    const token = await getToken();
+
+    // 处理参数
     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));
 
-    // 调用 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"';
+
+    let result;
+    let userMessage;
+
+    // 【调试日志】打印原始传入参数
+    console.error('\n========== MCP 参数调试日志 ==========');
+    console.error('工具名称:', name);
+    console.error('原始参数 agentType:', args.agentType || '(未传入)');
+    console.error('原始参数 apiProvider:', args.apiProvider || '(未传入)');
+    console.error('原始参数 rawInput:', args.rawInput ? args.rawInput.substring(0, 50) + '...' : '(未传入)');
+    console.error('原始参数 llm_provider:', args.llm_provider || '(未传入)');
+    console.error('原始参数 store:', args.store || '(未传入)');
+    console.error('======================================\n');
+
+    // 根据工具类型选择处理流程
+    switch (name) {
+      /*
+      case 'quick_book': {
+        // 极简快捷记账：自动识别支出/收入，智能匹配分类
+        console.log('处理极简快捷记账...');
+        
+        // 1. 从环境变量补充参数（确保上报）
+        const agentType = process.env.AGENT_TYPE || process.env.MCP_AGENT_TYPE || args.agentType || '';
+        const apiProvider = process.env.API_PROVIDER || process.env.MCP_API_PROVIDER || args.apiProvider || '';
+        const rawInput = args.rawInput || args.name;
+        
+        // 2. 判断是支出还是收入
+        const isIncome = isIncomeName(args.name);
+        
+        // 3. 智能匹配分类
+        const category = args.category || getCategory(args.name);
+        
+        // 4. 自动补全参数
+        const completedArgs = {
+          name: sanitizeString(args.name, 100),
+          amount: validateAmount(args.amount),
+          price: args.price || validateAmount(args.amount),
+          quantity: args.quantity || 1,
+          unit: args.unit || '个',
+          category: category,
+          store: sanitizeString(args.store, 100) || '未知商家',
+          note: sanitizeString(args.note, 500),
+          agentType: agentType,
+          apiProvider: apiProvider,
+          rawInput: rawInput,
+          mcp_version: MCP_VERSION,
+        };
+        
+        // 5. 根据类型选择接口
+        if (isIncome) {
+          // 收入记账
+          console.log('识别为收入，调用 save_income...');
+          const mcpParams = convertParams('save_income', completedArgs);
+          result = await callMcpHub('addIncome', mcpParams, token);
+          
+          if (result.success) {
+            userMessage = `✅ 记账成功\n\n| 收入来源 | 金额 | 分类 |\n|------|------|------|\n| ${completedArgs.name} | ${completedArgs.amount}元 | ${completedArgs.category || '其他收入'} |\n\n已保存到你的柴米记账小程序数据库。`;
+          }
+        } else {
+          // 支出记账
+          console.log('识别为支出，调用 save_expense...');
+          const mcpParams = convertParams('save_expense', completedArgs);
+          result = await callMcpHub('addExpense', mcpParams, token);
+          
+          if (result.success) {
+            userMessage = `✅ 记账成功\n\n| 商品 | 金额 | 分类 | 商家 |\n|------|------|------|------|\n| ${completedArgs.name} | ${completedArgs.amount}元 | ${completedArgs.category || '其他'} | ${completedArgs.store} |\n\n已保存到你的柴米记账小程序数据库。`;
+          }
+        }
+        break;
+      }
+      */
+      
+      case 'save_expense': {
+        // 步骤1：校验数据完整性
+        console.log('校验消费数据完整性...');
+        const validationResult = await callMcpPrompt(
+          'validateResult',
+          {
+            data: processedArgs,
+            type: 'parseText'
+          },
+          token
+        );
+        
+        if (validationResult.success && !validationResult.data.valid) {
+          console.log('数据不完整，尝试补充默认值:', validationResult.data);
+          // 调用 fillDefaults 补充缺失字段
+          const fillResult = await callMcpPrompt(
+            'fillDefaults',
+            {
+              data: processedArgs,
+              type: 'parseText'
+            },
+            token
+          );
+          
+          if (fillResult.success) {
+            processedArgs = fillResult.data;
+            console.log('补充后的数据:', processedArgs);
+          }
+        }
+        
+        // 步骤2：转换参数并调用 mcpHub 保存
+        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已保存到你的柴米记账小程序数据库。`;
+          
+          // 提示Agent可以传递agentType和apiProvider参数
+          if (!processedArgs.agentType || !processedArgs.apiProvider) {
+            userMessage += '\n\n💡 提示：传递agentType和apiProvider参数可解锁小程序记录来源统计功能，示例：agentType="openclaw", apiProvider="doubao"';
+          }
+        }
+        break;
+      }
+
+      case 'save_receipt': {
+        // 步骤1：校验数据完整性
+        console.log('校验小票数据完整性...');
+        const validationResult = await callMcpPrompt(
+          'validateResult',
+          {
+            data: processedArgs,
+            type: 'parseReceipt'
+          },
+          token
+        );
+        
+        if (validationResult.success && !validationResult.data.valid) {
+          console.log('数据不完整，尝试补充默认值:', validationResult.data);
+          // 调用 fillDefaults 补充缺失字段
+          const fillResult = await callMcpPrompt(
+            'fillDefaults',
+            {
+              data: processedArgs,
+              type: 'parseReceipt'
+            },
+            token
+          );
+          
+          if (fillResult.success) {
+            processedArgs = fillResult.data;
+            console.log('补充后的数据:', processedArgs);
+          }
+        }
+        
+        // 步骤2：转换参数并调用 mcpHub 保存
+        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已保存到你的柴米记账小程序数据库。`;
+          
+          // 提示Agent可以传递agentType和apiProvider参数
+          if (!processedArgs.agentType || !processedArgs.apiProvider) {
+            userMessage += '\n\n💡 提示：传递agentType和apiProvider参数可解锁小程序记录来源统计功能，示例：agentType="openclaw", apiProvider="doubao"';
+          }
+        }
+        break;
+      }
+
+      case 'get_expenses':
+      case 'get_receipt_list': {
+        // 查询类工具直接调用 mcpHub
+        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': {
+        // 查询类工具直接调用 mcpHub
+        const toolName = toolMapping[name];
+        const mcpParams = convertParams(name, processedArgs);
+        result = await callMcpHub(toolName, mcpParams, token);
+
+        if (result.success) {
+          userMessage = `📈 统计查询成功`;
+        }
+        break;
+      }
+
+      case 'save_income': {
+        // 收入记录直接调用 mcpHub
+        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,
         },
       ],
     };
   } catch (error) {
+    console.error('工具调用错误:', error);
     return {
       content: [
         {
@@ -218,44 +628,244 @@ 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 '';
+  // 去除 HTML 标签，防止 XSS
+  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');
-  }
+  // 匹配数字+单位，如 "300g", "2kg", "1.5斤"
+  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; // 1斤 = 500g
+    default:
+      return value;
+  }
+}
+
+// 计算市场单价（元/500g）
+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}`;
+  // 计算每500g的价格
+  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,    // 数量默认为1
+        category: sanitizeString(args.category, 50) || '其他',
+        store: sanitizeString(args.store, 100) || '',
+        type: 'expense',
+        unit: '',
+        weight: '',
+        marketPrice: '',
+        date: args.date,
+        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': {
+      // 处理 items 可能是 JSON 字符串的情况
+      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);
+          // 优先使用传入的 marketPrice，如果没有则自动计算
+          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,
+        date: args.date,
+        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() {
+  console.error('========================================');
+  console.error('柴米记账 MCP Server 启动中...');
+  console.error('========================================\n');
+
+  // 初始化 OAuth 管理器
+  console.error('🔄 初始化 OAuth 2.0 认证...');
+  initOAuthManager();
+
+  // 尝试加载已有 Token 或启动授权流程
+  try {
+    const existingToken = await oauthManager.tokenStorage.load();
+    if (existingToken) {
+      console.error('✅ 发现已存储的 OAuth Token');
+      // 验证 Token 是否有效
+      const validToken = await oauthManager.getValidToken();
+      console.error('✅ OAuth Token 验证通过');
+      cachedToken = validToken.accessToken;
+      tokenExpireTime = validToken.expiresAt;
+    } else {
+      console.error('\n⚠️ 首次使用，需要完成 OAuth 授权');
+      console.error('请按以下步骤操作：');
+      console.error('1. 等待授权信息出现');
+      console.error('2. 在小程序中完成授权');
+      console.error('3. 授权成功后即可使用\n');
+
+      // 启动授权流程（这会阻塞，直到授权完成）
+      const newToken = await oauthManager.startAuthFlow();
+      cachedToken = newToken.accessToken;
+      tokenExpireTime = newToken.expiresAt;
+    }
+  } catch (err) {
+    console.error('\n❌ OAuth 初始化失败:', err.message);
+    console.error('请检查 MCP_OAUTH_URL 配置是否正确\n');
+    throw err;
+  }
+
+  console.error('\n========================================');
+  console.error('启动 MCP Server...');
+  console.error('========================================\n');
+
   const transport = new StdioServerTransport();
   await server.connect(transport);
-  console.error('柴米记账 MCP Server 已启动');
+  console.error('✅ 柴米记账 MCP Server 已启动');
+  console.error(`MCP_HUB_URL: ${MCP_HUB_URL}`);
+  console.error(`MCP_PROMPT_URL: ${MCP_PROMPT_URL}`);
+  console.error(`MCP_OAUTH_URL: ${MCP_OAUTH_URL}`);
 }
 
 main().catch(console.error);