chaimi-keep-mcp 3.1.46-beta.0 → 3.1.46-beta.1

package/README.md

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

package/package.json

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

package/server.js

@@ -376,7 +376,52 @@ const TOKEN_REFRESH_INTERVAL = 2 * 60 * 60 * 1000;
 let lastRefreshTime = 0;
 
 async function getToken() {
-  // 步骤1：检查内存缓存 Token（最快路径）
+  // 检查是否已授权
+  if (!authState.isAuthorized) {
+    // 先检查是否有保存的授权状态（从文件加载）
+    const savedAuthState = await oauthManager.loadAuthState();
+    if (savedAuthState && savedAuthState.deviceCode) {
+      // 检查验证码是否已过期
+      if (oauthManager.isAuthStateExpired(savedAuthState)) {
+        console.error('⏰ 保存的验证码已过期，清除并生成新的验证码');
+        await oauthManager.clearAuthState();
+        // 继续执行，生成新的验证码
+      } else {
+        // 验证码未过期，尝试直接获取token（用户可能已授权）
+        try {
+          const token = await oauthManager.pollForTokenOnce(savedAuthState.deviceCode);
+          if (token) {
+            // 授权成功
+            cachedToken = token.accessToken;
+            tokenExpireTime = token.expiresAt;
+            authState.isAuthorized = true;
+            await oauthManager.tokenStorage.save(token);
+            await oauthManager.clearAuthState();
+            console.error('✅ 授权成功！可以继续使用记账功能');
+            // 返回特殊标记，让上层知道这是刚完成授权的情况
+            throw new Error(`AUTH_JUST_COMPLETED:${cachedToken}`);
+          }
+          // 用户还未授权，返回同一个验证码
+          authState.deviceCode = savedAuthState.deviceCode;
+          authState.userCode = savedAuthState.userCode;
+          throw new Error(`NEED_AUTH:${savedAuthState.userCode}`);
+        } catch (err) {
+          if (err.message.startsWith('NEED_AUTH:') || err.message.startsWith('AUTH_JUST_COMPLETED:')) {
+            throw err;
+          }
+          // 其他错误，继续获取新的验证码
+          console.error('⚠️  检查授权状态失败:', err.message);
+        }
+      }
+    }
+    
+    // 没有保存的授权状态或已过期，启动新的授权流程
+    await startAuthFlow();
+    
+    // 返回验证码给Agent
+    throw new Error(`NEED_AUTH:${authState.userCode || '等待生成验证码'}`);
+  }
+
   if (cachedToken && tokenExpireTime > Date.now() + 5 * 60 * 1000) {
     if (Date.now() - lastRefreshTime < TOKEN_REFRESH_INTERVAL) {
       return cachedToken;
@@ -387,76 +432,18 @@ async function getToken() {
     throw new Error('OAuth 管理器未初始化，请检查 MCP_OAUTH_URL 配置');
   }
 
-  // 步骤2：尝试从文件加载并刷新 Token
   try {
     const oauthToken = await oauthManager.getValidToken();
     cachedToken = oauthToken.accessToken;
     tokenExpireTime = oauthToken.expiresAt;
     lastRefreshTime = Date.now();
-    authState.isAuthorized = true;
     await oauthManager.clearAuthState();
     return cachedToken;
   } catch (err) {
-    // Token 无效，需要重新授权
-    console.error('⏰ Token 无效，需要重新授权:', err.message);
-  }
-
-  // 步骤3：检查是否有保存的授权状态（用户可能正在授权中）
-  const savedAuthState = await oauthManager.loadAuthState();
-  if (savedAuthState && savedAuthState.deviceCode) {
-    // 检查验证码是否已过期
-    if (oauthManager.isAuthStateExpired(savedAuthState)) {
-      console.error('⏰ 保存的验证码已过期，清除并生成新的验证码');
-      await oauthManager.clearAuthState();
-    } else {
-      // 验证码未过期，尝试直接获取token（用户可能已授权）
-      try {
-        const token = await oauthManager.pollForTokenOnce(savedAuthState.deviceCode);
-        if (token) {
-          // 授权成功
-          cachedToken = token.accessToken;
-          tokenExpireTime = token.expiresAt;
-          authState.isAuthorized = true;
-          await oauthManager.tokenStorage.save(token);
-          await oauthManager.clearAuthState();
-          console.error('✅ 授权成功！可以继续使用记账功能');
-          // 返回特殊标记，让上层知道这是刚完成授权的情况
-          throw new Error(`AUTH_JUST_COMPLETED:${cachedToken}`);
-        }
-        // 用户还未授权，启动轮询等待
-        console.error(`⏳ 等待用户授权，验证码：${savedAuthState.userCode}`);
-        const authResult = await waitForAuthWithPolling(savedAuthState.deviceCode, savedAuthState.userCode, 120000);
-        if (authResult.success) {
-          cachedToken = authResult.token.accessToken;
-          tokenExpireTime = authResult.token.expiresAt;
-          authState.isAuthorized = true;
-          await oauthManager.tokenStorage.save(authResult.token);
-          await oauthManager.clearAuthState();
-          return cachedToken;
-        } else {
-          throw new Error(`NEED_AUTH:${savedAuthState.userCode}`);
-        }
-      } catch (err) {
-        if (err.message.startsWith('NEED_AUTH:') || err.message.startsWith('AUTH_JUST_COMPLETED:')) {
-          throw err;
-        }
-        console.error('⚠️  检查授权状态失败:', err.message);
-      }
-    }
-  }
-
-  // 步骤4：启动新的授权流程并等待
-  console.error('🔐 启动新的授权流程...');
-  const authResult = await startAuthFlowAndWait(120000);
-
-  if (authResult.success) {
-    cachedToken = authResult.token.accessToken;
-    tokenExpireTime = authResult.token.expiresAt;
-    authState.isAuthorized = true;
-    return cachedToken;
-  } else {
-    // 超时或失败，抛出错误让 Agent 知道需要用户介入
-    throw new Error(`NEED_AUTH:${authResult.userCode || '授权超时，请再次调用'}`);
+    // Token 获取失败，可能需要重新授权
+    authState.isAuthorized = false;
+    authState.isWaiting = false;
+    throw new Error(`NEED_AUTH:授权已过期，请重新授权`);
   }
 }
 
@@ -1823,112 +1810,106 @@ async function main() {
   await server.connect(transport);
 }
 
-// 延迟函数
-function delay(ms) {
-  return new Promise(resolve => setTimeout(resolve, ms));
+// 启动授权流程（获取验证码，启动后台轮询）
+async function startAuthFlow() {
+  try {
+    // 先检查是否有保存的授权状态
+    const savedAuthState = await oauthManager.loadAuthState();
+    if (savedAuthState && savedAuthState.userCode) {
+      // 检查验证码是否过期
+      if (oauthManager.isAuthStateExpired(savedAuthState)) {
+        console.error('⏰ 验证码已过期，生成新的验证码');
+        await oauthManager.clearAuthState();
+      } else {
+        // 有保存的验证码，直接使用
+        authState.deviceCode = savedAuthState.deviceCode;
+        authState.userCode = savedAuthState.userCode;
+        authState.isWaiting = true;
+        console.error(`🔑 使用已保存的验证码：${savedAuthState.userCode}`);
+        // 启动后台轮询
+        pollForAuthInBackground(savedAuthState.deviceCode, 5000);
+        return;
+      }
+    }
+
+    // 获取新的设备码
+    const deviceCodeRes = await oauthManager.requestDeviceCode(false);
+    authState.deviceCode = deviceCodeRes.deviceCode;
+    authState.userCode = deviceCodeRes.userCode;
+    authState.isWaiting = true;
+
+    // 保存授权状态（30分钟有效）
+    await oauthManager.saveAuthState({
+      deviceCode: deviceCodeRes.deviceCode,
+      userCode: deviceCodeRes.userCode,
+      expiresAt: Date.now() + deviceCodeRes.expiresIn * 1000
+    });
+
+    console.error(`🔑 验证码：${deviceCodeRes.userCode}`);
+    console.error('⏳ 请在小程序中完成授权，然后再次调用');
+    
+    // 启动后台轮询（3分钟）
+    pollForAuthInBackground(deviceCodeRes.deviceCode, 5000);
+
+  } catch (err) {
+    authState.error = err.message;
+    authState.isWaiting = false;
+    console.error('❌ 启动授权失败:', err.message);
+  }
 }
 
-// 等待授权完成（带轮询）- 方案三实现
-async function waitForAuthWithPolling(deviceCode, userCode, timeout = 120000) {
-  const startTime = Date.now();
-  const interval = 5000; // 5秒轮询一次
+// 后台轮询授权状态（3分钟）
+async function pollForAuthInBackground(deviceCode, interval) {
+  const maxAttempts = 36; // 3分钟（36次 × 5秒）
+  let attempts = 0;
 
-  console.error(`⏳ 等待用户授权中...（验证码：${userCode}）`);
-  console.error('   请打开"柴米AI记账"小程序完成授权');
+  console.error('⏳ 等待用户授权中...（3分钟内有效）');
 
-  while (Date.now() - startTime < timeout) {
+  while (attempts < maxAttempts && authState.isWaiting) {
+    attempts++;
     await delay(interval);
 
     try {
       // 调用云函数检查授权状态
       const token = await oauthManager.pollForTokenOnce(deviceCode);
-
+      
       if (token) {
         // 授权成功
-        console.error('✅ 检测到用户授权成功！');
-        return { success: true, token };
+        cachedToken = token.accessToken;
+        tokenExpireTime = token.expiresAt;
+        authState.isAuthorized = true;
+        authState.isWaiting = false;
+        
+        // 保存token到文件
+        await oauthManager.tokenStorage.save(token);
+        // 清除授权状态
+        await oauthManager.clearAuthState();
+        
+        console.error('✅ 授权成功！下次调用将快速启动');
+        
+        // 主动退出进程，让 mcporter 下次重新启动
+        process.exit(0);
       }
     } catch (err) {
       if (err.message.includes('expired') || err.message.includes('invalid')) {
+        authState.error = err.message;
+        authState.isWaiting = false;
         console.error('❌ 授权失败:', err.message);
-        return { success: false, error: err.message };
+        process.exit(1);
       }
       // 继续轮询
     }
-
-    // 输出等待提示（每30秒一次）
-    const elapsed = Math.floor((Date.now() - startTime) / 1000);
-    if (elapsed % 30 === 0) {
-      console.error(`   已等待 ${elapsed} 秒...`);
-    }
   }
 
-  // 超时
-  console.error('⏰ 等待授权超时（2分钟）');
-  return { success: false, error: 'timeout', userCode };
+  // 3分钟超时
+  authState.isWaiting = false;
+  console.error('⏰ 授权超时，请再次调用获取新验证码');
+  process.exit(0);
 }
 
-// 启动授权流程并等待 - 方案三实现
-async function startAuthFlowAndWait(timeout = 120000) {
-  try {
-    // 检查是否已有进行中的授权流程（防止并发）
-    if (authState.isWaiting) {
-      console.error('⏳ 已有进行中的授权流程，等待完成...');
-      // 等待现有流程完成
-      const startTime = Date.now();
-      while (authState.isWaiting && Date.now() - startTime < timeout) {
-        await delay(1000);
-      }
-      // 如果授权成功，返回成功
-      if (authState.isAuthorized && cachedToken) {
-        return { success: true, token: { accessToken: cachedToken, expiresAt: tokenExpireTime } };
-      }
-      // 否则继续启动新的授权流程
-    }
-
-    // 设置等待状态（防止并发）
-    authState.isWaiting = true;
-    authState.error = null;
-
-    // 获取新的设备码
-    const deviceCodeRes = await oauthManager.requestDeviceCode(false);
-    const deviceCode = deviceCodeRes.deviceCode;
-    const userCode = deviceCodeRes.userCode;
-
-    // 保存授权状态（30分钟有效）
-    await oauthManager.saveAuthState({
-      deviceCode: deviceCode,
-      userCode: userCode,
-      expiresAt: Date.now() + deviceCodeRes.expiresIn * 1000
-    });
-
-    console.error(`🔑 验证码：${userCode}`);
-    console.error('━━━━━━━━━━━━━━');
-    console.error('📱 请打开"柴米AI记账"小程序：');
-    console.error('   1. 点击"我的" → "🤖 Agent 授权"');
-    console.error(`   2. 输入验证码：${userCode}`);
-    console.error('   3. 点击确认授权');
-    console.error('━━━━━━━━━━━━━━');
-    console.error(`⏳ 等待您授权完成（${Math.floor(timeout / 1000)}秒内）...`);
-
-    // 等待用户授权
-    const result = await waitForAuthWithPolling(deviceCode, userCode, timeout);
-
-    // 清除等待状态
-    authState.isWaiting = false;
-
-    if (result.success) {
-      return { success: true, token: result.token };
-    } else {
-      return { success: false, userCode, error: result.error };
-    }
-
-  } catch (err) {
-    // 清除等待状态
-    authState.isWaiting = false;
-    console.error('❌ 启动授权流程失败:', err.message);
-    return { success: false, error: err.message };
-  }
+// 延迟函数
+function delay(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
 }
 
 /**