chaimi-bookkeeping-mcp 2.3.4 → 2.3.5

package/README.md

@@ -70,22 +70,9 @@ MCP Server 会显示：
 
 ## 配置说明
 
-如果使用手动安装，需要配置 `~/.mcporter/mcporter.json`：
-
-```json
-{
-  "mcpServers": {
-    "柴米记账": {
-      "command": "chaimi-bookkeeping-mcp",
-      "env": {
-        "MCP_OAUTH_URL": "https://cloud1-2gfe5jhjef06b85d-1412172089.ap-shanghai.app.tcloudbase.com/mcpOAuth",
-        "MCP_HUB_URL": "https://cloud1-2gfe5jhjef06b85d-1412172089.ap-shanghai.app.tcloudbase.com/mcpHub-mcp",
-        "MCP_PROMPT_URL": "https://cloud1-2gfe5jhjef06b85d-1412172089.ap-shanghai.app.tcloudbase.com/mcpPrompt"
-      }
-    }
-  }
-}
-```
+npm 全局安装时会**自动配置**，无需手动操作。
+
+如需手动配置（如从 GitHub 下载安装），参考 `~/.mcporter/mcporter.json` 格式。
 
 ## 常见问题
 
@@ -141,6 +128,10 @@ AI 会自动调用 `save_income` 工具记录收入。
 
 ## 更新日志
 
+### v2.3.4 (2026-04-08)
+- **简化** `save_expense` 工具，只保留 `name` 和 `amount` 为必填参数
+- **优化** 其他参数使用默认值，简化 Agent 调用
+
 ### v2.3.3 (2026-04-08)
 - **修正** 版本号统一为 v2.3.3（包含 v2.3.2 的所有修复）
 

package/package.json

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

package/server.js

@@ -1,77 +1,29 @@
 #!/usr/bin/env node
 /**
  * 柴米记账 MCP Server (Node.js 版本)
- * 适配微信云函数 mcpHub
  * 支持 Claude Desktop、Cursor、WorkBuddy、OpenClaw
  */
 
-// 加载 .env 文件
-try {
-  require('dotenv').config();
-} catch (e) {
-  // dotenv 未安装，忽略
-}
-
 const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
 const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
 const {
   CallToolRequestSchema,
   ListToolsRequestSchema,
 } = require('@modelcontextprotocol/sdk/types.js');
-const path = require('path');
-const os = require('os');
 const fs = require('fs');
+const path = require('path');
 
-// 读取 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 已就绪，可以开始使用');
-    }
-  });
-
-  return oauthManager;
-}
+// 配置
+const SCF_URL = process.env.SCF_URL || 'https://1412172089-4wbwsop8pe.ap-shanghai.tencentscf.com';
 
 // 创建 MCP Server
 const server = new Server(
   {
-    name: 'chaimi-bookkeeping-mcp',
+    name: 'chaihuo-mcp-server',
     version: MCP_VERSION,
   },
   {
@@ -85,49 +37,26 @@ 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 类型（如：workbuddy、claude、cursor）' },
-            apiProvider: { type: 'string', description: 'AI 提供商' },
-            rawInput: { type: 'string', description: '用户原始输入' },
-            mcp_version: { type: 'string', description: 'MCP Server 版本号（自动填充）' },
-          },
-          required: ['name', 'amount'],
-        },
-      },
-      */
       {
         name: 'save_expense',
-        description: '保存单商品消费记录（AI文字记账）。只需提供商品名称和金额，其他参数自动填充。示例：name="午餐", amount=35',
+        description: '保存单商品消费记录（AI文字记账）',
         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 版本号（自动填充）' },
+            name: { type: 'string', description: '商品名称' },
+            amount: { type: 'number', description: '金额' },
+            category: { type: 'string', description: '分类（如：餐饮、食品、交通）' },
+            store: { 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: '【推荐自动填充】用户的原始输入内容，用于记录用户原始请求' },
           },
           required: ['name', 'amount'],
         },
       },
       {
         name: 'save_receipt',
-        description: '保存小票（多商品记账）',
+        description: '【图片小票专用】保存购物小票/发票/收据（支持单商品或多商品）。当用户提供图片形式的小票、发票、收据、购物清单时，无论商品数量多少（1条或多条），都必须使用此接口。可自动识别商家名称、商品明细、金额、优惠等信息。典型场景：超市购物小票、餐厅发票、线上订单截图、手写收据照片等',
         inputSchema: {
           type: 'object',
           properties: {
@@ -139,29 +68,28 @@ 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: '商品列表（必须是数组格式，如：[{"name":"苹果","amount":5.5,"price":5.5,"quantity":1}]，不要传JSON字符串）',
+              description: '商品列表',
               items: {
                 type: 'object',
                 properties: {
                   name: { type: 'string', description: '商品名称' },
                   originalName: { type: 'string', description: '原始商品名称' },
                   price: { type: 'number', description: '单价' },
-                  quantity: { type: 'number', description: '数量' },
+                  quantity: { type: 'string', description: '数量' },
                   unit: { type: 'string', description: '单位' },
                   amount: { type: 'number', description: '金额' },
                   weight: { type: 'string', description: '重量' },
                   marketPrice: { type: 'string', description: '市场单价' },
                   category: { type: 'string', description: '分类' },
                 },
-                required: ['name', 'amount', 'price', 'quantity'],
+                required: ['name', 'amount'],
               },
             },
-            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: ['store', 'items'],
         },
@@ -174,6 +102,9 @@ 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: '【推荐自动填充】用户的原始输入内容，用于记录用户原始请求' },
           },
         },
       },
@@ -184,6 +115,9 @@ 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: '【推荐自动填充】用户的原始输入内容，用于记录用户原始请求' },
           },
         },
       },
@@ -195,417 +129,76 @@ 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;
 
-  // 【强制日志】测试日志是否输出 - 写入文件
-  const fs = require('fs');
-
-  // 从环境变量获取 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;
-  }
-
-  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);
+  // 调试日志
+  console.error('收到工具调用请求:', name);
+  console.error('原始参数:', JSON.stringify(args, null, 2));
 
   try {
-    // 获取 Token
-    const token = await getToken();
+    // 获取 Token（这里需要实现 Token 生成逻辑）
+    const token = await generateToken();
+
+    // SCF 使用下划线命名，直接传递工具名
+    const action = name;
 
-    // 处理参数
+    // 处理参数 - 将字符串格式的 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;
-
-    // 【调试日志】打印原始传入参数
-    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已保存到你的柴米记账小程序数据库。`;
-        }
-        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已保存到你的柴米记账小程序数据库。`;
-        }
-        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 || '未知错误'}`;
+    // 调用 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"';
     }
 
-    // 添加版本信息提示
-    userMessage += `\n\n---\n📦 柴米记账 MCP v${MCP_VERSION}`;
-
     return {
       content: [
         {
           type: 'text',
-          text: userMessage,
+          text: responseText,
         },
       ],
     };
   } catch (error) {
-    console.error('工具调用错误:', error);
     return {
       content: [
         {
@@ -618,244 +211,44 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
   }
 });
 
-// 输入验证和过滤函数
-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;
-  
-  // 匹配数字+单位，如 "300g", "2kg", "1.5斤"
-  const match = weightStr.match(/(\d+\.?\d*)\s*(g|kg|斤|克|千克)/i);
-  if (!match) return 0;
-  
-  const value = parseFloat(match[1]);
-  const unit = match[2].toLowerCase();
+// 生成 JWT Token
+async function generateToken() {
+  const JWT_SECRET = process.env.JWT_SECRET;
+  const MCP_OPENID = process.env.MCP_OPENID;
   
-  // 转换为克
-  switch (unit) {
-    case 'g':
-    case '克':
-      return value;
-    case 'kg':
-    case '千克':
-      return value * 1000;
-    case '斤':
-      return value * 500; // 1斤 = 500g
-    default:
-      return value;
+  if (!JWT_SECRET) {
+    throw new Error('JWT_SECRET 环境变量未设置');
   }
-}
-
-// 计算市场单价（元/500g）
-function calculateMarketPrice(amount, weightStr) {
-  const amountNum = parseFloat(amount);
-  const weightInGrams = extractWeightInGrams(weightStr);
   
-  if (isNaN(amountNum) || amountNum <= 0 || weightInGrams <= 0) {
-    return '';
+  if (!MCP_OPENID) {
+    throw new Error('MCP_OPENID 环境变量未设置，请从小程序获取用户Token');
   }
   
-  // 计算每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}`;
+  // 使用 crypto 生成 JWT
+  const crypto = require('crypto');
+  
+  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
+  };
+  
+  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');
+  
+  return `${h}.${p}.${sig}`;
 }
 
 // 启动服务器
 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_HUB_URL: ${MCP_HUB_URL}`);
-  console.error(`MCP_PROMPT_URL: ${MCP_PROMPT_URL}`);
-  console.error(`MCP_OAUTH_URL: ${MCP_OAUTH_URL}`);
+  console.error('柴米记账 MCP Server 已启动');
 }
 
 main().catch(console.error);