chaimi-bookkeeping-mcp 2.3.7 → 2.3.10

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.7",
+  "version": "2.3.10",
   "description": "柴米记账 MCP Server - 支持 Claude、Cursor、OpenClaw、WorkBuddy 等 AI 工具直接记账",
   "main": "server.js",
   "bin": {

package/server.js

@@ -25,7 +25,6 @@ const fs = require('fs');
 // 读取 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');
@@ -52,16 +51,8 @@ function initOAuthManager() {
     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 已就绪，可以开始使用');
     }
   });
 
@@ -85,27 +76,6 @@ 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文字记账）。只需提供商品名称和金额，其他参数自动填充。示例：name="午餐", amount=35',
@@ -127,7 +97,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
       },
       {
         name: 'save_receipt',
-        description: '【图片小票专用】保存购物小票/发票/收据（支持单商品或多商品）。当用户提供图片形式的小票、发票、收据、购物清单时，无论商品数量多少（1条或多条），都必须使用此接口。可自动识别商家名称、商品明细、金额、优惠等信息。典型场景：超市购物小票、餐厅发票、线上订单截图、手写收据照片等',
+        description: '【图片小票专用】保存购物小票/发票/收据（支持单商品或多商品）。当用户提供图片形式的小票、发票时，无论商品数量多少（1条或多条），都必须使用此接口。可自动识别商家名称、商品明细、金额、优惠等信息。典型场景：超市购物小票、餐厅发票、线上订单截图、手写收据照片等',
         inputSchema: {
           type: 'object',
           properties: {
@@ -210,9 +180,9 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             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: '用户原始输入' },
+            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'],
@@ -222,9 +192,8 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
   };
 });
 
-// 工具名称映射：SCF action -> mcpHub tool
+// 工具名称映射：MCP Tool -> mcpHub Tool
 const toolMapping = {
-  'quick_book': 'addExpense',  // quick_book 内部会判断支出/收入
   'save_expense': 'addExpense',
   'save_receipt': 'addReceipt',
   'save_income': 'addIncome',
@@ -234,26 +203,16 @@ const toolMapping = {
 };
 
 // 获取或刷新 Token（OAuth 2.0 Device Flow）
-// 自动刷新周期：2小时（测试用，生产环境建议24小时）
-const TOKEN_REFRESH_INTERVAL = 2 * 60 * 60 * 1000; // 2小时
+const TOKEN_REFRESH_INTERVAL = 2 * 60 * 60 * 1000;
 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 配置');
   }
@@ -263,31 +222,18 @@ async function getToken() {
     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;
   }
@@ -341,14 +287,9 @@ async function callMcpHub(tool, params, token) {
 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;
   }
@@ -356,138 +297,25 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     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);
-
   try {
-    // 获取 Token
     const token = await getToken();
 
-    // 处理参数
     const processedArgs = { ...args };
     if (processedArgs.items && typeof processedArgs.items === 'string') {
       try {
         processedArgs.items = JSON.parse(processedArgs.items);
       } catch (e) {
-        // 解析失败，保持原样
       }
     }
 
-
-
     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;
@@ -495,7 +323,6 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           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"';
           }
@@ -504,8 +331,6 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       }
 
       case 'save_receipt': {
-        // 步骤1：校验数据完整性
-        console.log('校验小票数据完整性...');
         const validationResult = await callMcpPrompt(
           'validateResult',
           {
@@ -516,8 +341,6 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         );
         
         if (validationResult.success && !validationResult.data.valid) {
-          console.log('数据不完整，尝试补充默认值:', validationResult.data);
-          // 调用 fillDefaults 补充缺失字段
           const fillResult = await callMcpPrompt(
             'fillDefaults',
             {
@@ -528,16 +351,25 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           );
           
           if (fillResult.success) {
+            const savedAgentType = processedArgs.agentType;
+            const savedApiProvider = processedArgs.apiProvider;
+            const savedRawInput = processedArgs.rawInput;
             processedArgs = fillResult.data;
-            console.log('补充后的数据:', processedArgs);
+            if (savedAgentType) {
+              processedArgs.agentType = savedAgentType;
+            }
+            if (savedApiProvider) {
+              processedArgs.apiProvider = savedApiProvider;
+            }
+            if (savedRawInput) {
+              processedArgs.rawInput = savedRawInput;
+            }
           }
         }
         
-        // 步骤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') || '暂无商品明细';
@@ -545,7 +377,6 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           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"';
           }
@@ -555,7 +386,6 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
       case 'get_expenses':
       case 'get_receipt_list': {
-        // 查询类工具直接调用 mcpHub
         const toolName = toolMapping[name];
         const mcpParams = convertParams(name, processedArgs);
         result = await callMcpHub(toolName, mcpParams, token);
@@ -567,7 +397,6 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       }
 
       case 'get_statistics': {
-        // 查询类工具直接调用 mcpHub
         const toolName = toolMapping[name];
         const mcpParams = convertParams(name, processedArgs);
         result = await callMcpHub(toolName, mcpParams, token);
@@ -579,11 +408,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       }
 
       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;
@@ -598,12 +425,10 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         throw new Error(`未知工具: ${name}`);
     }
 
-    // 处理错误
     if (!result.success) {
       userMessage = `❌ 操作失败：${result.error || '未知错误'}`;
     }
 
-    // 添加版本信息提示
     userMessage += `\n\n---\n📦 柴米记账 MCP v${MCP_VERSION}`;
 
     return {
@@ -615,7 +440,6 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       ],
     };
   } catch (error) {
-    console.error('工具调用错误:', error);
     return {
       content: [
         {
@@ -628,10 +452,8 @@ 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);
 }
 
@@ -645,18 +467,15 @@ function validateQuantity(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();
   
-  // 转换为克
   switch (unit) {
     case 'g':
     case '克':
@@ -665,13 +484,12 @@ function extractWeightInGrams(weightStr) {
     case '千克':
       return value * 1000;
     case '斤':
-      return value * 500; // 1斤 = 500g
+      return value * 500;
     default:
       return value;
   }
 }
 
-// 计算市场单价（元/500g）
 function calculateMarketPrice(amount, weightStr) {
   const amountNum = parseFloat(amount);
   const weightInGrams = extractWeightInGrams(weightStr);
@@ -680,16 +498,13 @@ function calculateMarketPrice(amount, weightStr) {
     return '';
   }
   
-  // 计算每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（商品名称）');
       }
@@ -704,15 +519,14 @@ function convertParams(toolName, args) {
         name: name,
         originalName: name,
         amount: amount,
-        price: amount,  // 单价默认等于金额
-        quantity: 1,    // 数量默认为1
+        price: amount,
+        quantity: 1,
         category: sanitizeString(args.category, 50) || '其他',
         store: sanitizeString(args.store, 100) || '',
-        type: 'expense',
+        transactionType: 'expense',
         unit: '',
         weight: '',
         marketPrice: '',
-        date: args.date,
         note: sanitizeString(args.note, 500) || '',
         rawInput: sanitizeString(args.rawInput, 1000) || '',
         agentType: args.agentType || '',
@@ -723,7 +537,6 @@ function convertParams(toolName, args) {
     }
 
     case 'save_receipt': {
-      // 处理 items 可能是 JSON 字符串的情况
       let items = args.items;
       if (typeof items === 'string') {
         try {
@@ -740,7 +553,6 @@ function convertParams(toolName, args) {
         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 {
@@ -769,7 +581,6 @@ function convertParams(toolName, args) {
         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 || '',
@@ -811,61 +622,32 @@ function convertParams(toolName, 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_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);
+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

package/test-parent-process.js

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+
+const { execSync } = require('child_process');
+const os = require('os');
+
+console.log('='.repeat(60));
+console.log('父进程信息检测工具');
+console.log('='.repeat(60));
+
+console.log('\n1. 当前进程信息:');
+console.log(`   PID: ${process.pid}`);
+console.log(`   父进程 PID (PPID): ${process.ppid}`);
+console.log(`   当前平台: ${process.platform}`);
+
+console.log('\n2. 尝试获取父进程信息:');
+
+if (process.platform === 'darwin' || process.platform === 'linux') {
+  try {
+    const psOutput = execSync(`ps -p ${process.ppid} -o pid,ppid,command`, { encoding: 'utf8' });
+    console.log('   ' + psOutput.replace(/\n/g, '\n   '));
+
+    const ppidOutput = execSync(`ps -p ${process.ppid} -o command=`, { encoding: 'utf8' }).trim();
+    console.log(`\n   父进程命令: ${ppidOutput}`);
+
+    const guessAgentType = (cmd) => {
+      if (/claude/i.test(cmd)) return 'claude-desktop';
+      if (/cursor/i.test(cmd)) return 'cursor';
+      if (/continue/i.test(cmd)) return 'continue';
+      if (/zed/i.test(cmd)) return 'zed';
+      if (/workbuddy/i.test(cmd)) return 'workbuddy';
+      if (/openclaw/i.test(cmd)) return 'openclaw';
+      return 'unknown';
+    };
+
+    console.log(`   猜测的 Agent 类型: ${guessAgentType(ppidOutput)}`);
+
+  } catch (e) {
+    console.log(`   获取父进程信息失败: ${e.message}`);
+  }
+} else if (process.platform === 'win32') {
+  try {
+    const wmicOutput = execSync(`wmic process where processid=${process.ppid} get processid,parentprocessid,commandline`, { encoding: 'utf8' });
+    console.log('   ' + wmicOutput.replace(/\n/g, '\n   '));
+  } catch (e) {
+    console.log(`   获取父进程信息失败: ${e.message}`);
+  }
+}
+
+console.log('\n' + '='.repeat(60));