creditdaddy 1.3.0 → 1.4.0

package/src/minimaxGateway.js

@@ -5,7 +5,7 @@
  * （上游为标准 Anthropic Messages 协议：https://agent.minimax.cn/mavis/api/v1/llm/v1/messages）
  *
  * 架构特性：
- * 1. 账号多路轮换（provider=minimax）：自动在有效账号间轮询
+ * 1. 多账号粘性主力（provider=minimax）：按剩余积分选主力并保持，出错/限流/凭据失效自动切下一个
  * 2. 自动刷新与重试：401 凭据失效时自动走 OAuth refresh 换取新 token 并重试，彻底失效才拉黑
  * 3. 429 限流保护：429 限流自动冷却 5 分钟
  * 4. 局域网访问控制：继承相同的白名单与回环检查机制
@@ -17,11 +17,13 @@ import { loadAccounts, loadSettings, saveSettings } from './store.js';
 import { refreshMiniMaxToken, fetchMiniMaxQuota, MINIMAX_MESSAGES_URL } from './minimaxClient.js';
 import { refreshContext } from './accounts.js';
 import { gatewayHostSuggestion } from './tenrouter.js';
-import { logger } from './logger.js';
+import { logger, summarizeAttempts } from './logger.js';
+import { t } from './i18n.js';
 
 const ACCOUNT_COOLING_MS = 5 * 60_000;
 const MAX_ATTEMPTS = 5;
 const UPSTREAM_TIMEOUT_MS = 600_000;
+const UPSTREAM_CONNECT_MS = 15_000;
 
 // ── 开关（持久化在 settings.minimaxGateway） ──
 
@@ -44,7 +46,8 @@ export async function setGatewayEnabled(v) {
 
 const cooling = new Map();  // accountId → 冷却截止(ms)
 const dead = new Map();     // accountId → 拉黑时的凭据指纹（指纹变化 = 已重新授权/刷新，自动复活）
-const weights = new Map();  // accountId → 上次查到的剩余积分（0 时按保底权重轮询，保持可用性）
+const weights = new Map();  // accountId → { w: 剩余积分权重, at: 查询时刻 }(查询失败时保留旧快照)
+const WEIGHT_TTL_MS = 10 * 60_000;  // 权重超过该时长重新查询额度,让用量变化能反映到分流上
 
 export const stats = {
   lastCallAt: null,
@@ -79,43 +82,50 @@ function isDead(account) {
   if (fp === credFingerprint(account)) return true;
   dead.delete(account.id);
   cooling.delete(account.id);
-  logger.info('MINIMAX-GW', `${account.name || account.uid || account.id} 凭据已更新，解除拉黑`);
+  logger.info('MINIMAX-GW', '{label} 凭据已更新,解除拉黑', { label: account.name || account.uid || account.id });
   return false;
 }
 
+/** 测试专用：仅让权重快照过期（保留粘性/拉黑状态），用于模拟额度变化 */
+export function __expireWeightsForTests() { weights.clear(); }
+
 /** 测试专用：清空进程内状态 */
 export function __resetForTests() {
   cooling.clear();
   dead.clear();
   weights.clear();
-  swrr.clear();
+  stickyId = null;
   stats.lastCallAt = null;
   stats.calls = 0;
   stats.lastAccount = null;
 }
 
-/** 账号权重：剩余积分（上次快照，避免每个请求都打额度接口）。查不到用保底权重。 */
+/** 账号权重:剩余积分(带 TTL 的快照,避免每个请求都打额度接口)。查询失败时保留上次快照权重。 */
 async function accountWeight(a) {
-  if (!weights.has(a.id)) {
-    try {
-      const q = await fetchMiniMaxQuota(a, refreshContext(a, (m) => logger.info('MINIMAX-GW', `${a.name || a.uid || a.id} ${m}`)));
-      const remaining = Number(q?.remaining) || 0;
-      weights.set(a.id, Math.max(MIN_WEIGHT, remaining));
-    } catch {
-      weights.set(a.id, MIN_WEIGHT);
-    }
+  const hit = weights.get(a.id);
+  if (hit && Date.now() - hit.at < WEIGHT_TTL_MS) return hit.w;
+  let w = hit?.w ?? MIN_WEIGHT;
+  try {
+    const q = await fetchMiniMaxQuota(a, refreshContext(a, (m) => logger.info("MINIMAX-GW", t('{label} {msg}', { label: a.name || a.uid || a.id, msg: m }))));
+    w = Math.max(MIN_WEIGHT, Number(q?.remaining) || 0);
+  } catch {
+    // 额度查询失败时保留上次快照权重：一次网络抖动不该把主力账号踢成保底权重、引发主力来回切换
   }
-  return weights.get(a.id);
+  weights.set(a.id, { w, at: Date.now() });
+  return w;
 }
 
-// SWRR 状态：accountId → 当前有效权重（每次调度累加，被选中的减去总权重）
-const swrr = new Map();
-function ensureSwrr(id) { if (!swrr.has(id)) swrr.set(id, 0); }
+// ── 粘性主力选型 ──
+// 上次的主力账号仍健康时继续用它：两个账号积分接近时若逐请求轮换，会在两账号间
+// 交替刷屏（「一主一备」困扰的来源，用户期望「出错/积分拉开差距才换」）；
+// 仅当另一账号剩余积分明显更多，或主力被拉黑/冷却，才主动换主力。
+let stickyId = null;
+const STICKY_MARGIN_RATIO = 0.1; // 积分领先超过 10% 才换
+const STICKY_MARGIN_ABS = 50;    // 且绝对差超过 50 积分
 
 /**
- * 可参与轮转的 MiniMax 账号队列，按剩余积分加权排序（SWRR）。
- * 返回 [账号, ...]：首个为本次该分到的账号；MAX_ATTEMPTS 只取队列头部用于重试，
- * 所以这里直接把权重最高的放最前，其余按有效权重降序兜底。
+ * 可用账号队列：队首 = 本次主力账号，其余按剩余积分降序作重试兜底。
+ * 拉黑/冷却在挂载时剔除；扭转主力粘性见上方说明。
  */
 async function rotationQueue() {
   const all = (await loadAccounts()).filter((a) => a.provider === 'minimax');
@@ -125,24 +135,23 @@ async function rotationQueue() {
     if (isDead(a)) continue;
     if ((cooling.get(a.id) || 0) > now) continue;
     if (!a.token) continue;
-    ensureSwrr(a.id);
-    const w = await accountWeight(a);
-    swrr.set(a.id, (swrr.get(a.id) || 0) + w);
-    ready.push({ account: a, weight: w });
+    ready.push({ account: a, weight: await accountWeight(a) });
   }
   if (!ready.length) return [];
 
-  // 有效权重最大者中签（SWRR 的「选出 current 最大」步）
-  let pick = ready[0];
-  for (const it of ready) if ((swrr.get(it.account.id) || 0) > (swrr.get(pick.account.id) || 0)) pick = it;
-  const total = ready.reduce((s, it) => s + it.weight, 0);
-  swrr.set(pick.account.id, (swrr.get(pick.account.id) || 0) - total);
-
-  // 队首 = 本次中签账号；其余按剩余积分降序（重试兜底顺序）
-  const rest = ready.filter((it) => it.account.id !== pick.account.id)
-    .sort((x, y) => y.weight - x.weight)
-    .map((it) => it.account);
-  return [pick.account, ...rest];
+  ready.sort((x, y) => y.weight - x.weight);
+  let head = ready[0];
+  const sticky = stickyId ? ready.find((it) => it.account.id === stickyId) : null;
+  if (sticky && sticky.account.id !== head.account.id) {
+    const margin = Math.max(STICKY_MARGIN_ABS, head.weight * STICKY_MARGIN_RATIO);
+    if (head.weight - sticky.weight < margin) head = sticky;
+  }
+  if (stickyId && stickyId !== head.account.id) {
+    const from = all.find((a) => a.id === stickyId);
+    logger.info('MINIMAX-GW', '主力账号 {from} → {to}（剩余积分领先）', { from: from?.name || from?.uid || stickyId, to: head.account.name || head.account.uid || head.account.id });
+  }
+  stickyId = head.account.id;
+  return [head.account, ...ready.filter((it) => it.account.id !== head.account.id).map((it) => it.account)];
 }
 
 async function unavailableReason() {
@@ -177,7 +186,13 @@ function remoteAllowed(remote, allowList) {
   return (Array.isArray(allowList) ? allowList : []).some((entry) => {
     const e = String(entry || '').trim();
     if (!e) return false;
-    if (e.endsWith('*')) return host.toLowerCase().startsWith(e.slice(0, -1).toLowerCase());
+    if (e.endsWith('*')) {
+      // 通配要求带点段尾：防止 192.168.31.1* 这类把 .100-.199 整段一起放行的怪手。
+      // 要扩整段子网，把写法统一为 192.168.31.*（带尾句点）。
+      const prefix = e.slice(0, -1);
+      if (!prefix.endsWith('.')) return false;
+      return host.toLowerCase().startsWith(prefix.toLowerCase());
+    }
     return host.toLowerCase() === e.toLowerCase();
   });
 }
@@ -212,7 +227,8 @@ export async function handleGateway(req, res) {
     res.writeHead(405, { 'Content-Type': 'application/json' });
     return res.end(JSON.stringify({ error: 'POST /gateway/minimax/v1/messages（Anthropic /v1/messages 形态）' }));
   }
-  if (!(await gatewayEnabled())) {
+  const settings = await loadSettings();
+  if (settings.minimaxGateway !== true) {
     res.writeHead(503, { 'Content-Type': 'application/json' });
     return res.end(JSON.stringify({ error: 'MiniMax 本地网关未开启（面板 → MiniMax → 接口设置）' }));
   }
@@ -220,7 +236,6 @@ export async function handleGateway(req, res) {
   // 局域网访问控制
   const remote = (req.socket && req.socket.remoteAddress) || '';
   if (!isLoopbackRemote(remote)) {
-    const settings = await loadSettings();
     if (settings.minimaxGatewayLan !== true) {
       res.writeHead(403, { 'Content-Type': 'application/json' });
       return res.end(JSON.stringify({ error: 'MiniMax 网关未允许局域网访问（面板 → MiniMax → 接口设置）' }));
@@ -251,14 +266,15 @@ export async function handleGateway(req, res) {
   stats.calls += 1;
 
   const attempted = [];
+  const clientAbort = new AbortController();
+  req.once('close', () => { if (!res.writableEnded) clientAbort.abort(); });
+
   for (let i = 0; i < Math.min(MAX_ATTEMPTS, queue.length); i++) {
     const account = queue[i];
     if (isDead(account) || (cooling.get(account.id) || 0) > Date.now()) continue;
     const label = account.name || account.uid || account.id;
 
     let upstream;
-    const controller = new AbortController();
-    req.on('close', () => controller.abort());
 
     let activeToken = account.token;
     const sendUpstream = async (tok) => {
@@ -273,7 +289,8 @@ export async function handleGateway(req, res) {
         headers,
         body: rawBody,
         timeoutMs: UPSTREAM_TIMEOUT_MS,
-        signal: controller.signal,
+        connectMs: UPSTREAM_CONNECT_MS,
+        signal: clientAbort.signal,
       });
     };
 
@@ -281,12 +298,12 @@ export async function handleGateway(req, res) {
       upstream = await sendUpstream(activeToken);
       // 如果 401 且账号有 refreshToken，尝试就地刷新一次并重试
       if (upstream.status === 401 && account.refreshToken) {
-        logger.info('MINIMAX-GW', `${label} 收到 401，尝试刷新凭据…`);
+        logger.info('MINIMAX-GW', '{label} 收到 401,尝试刷新凭据...', { label });
         try {
           // 本机导入账号：刷新前对齐 ~/.minimax auth.json 里客户端最新的 refreshToken，避免 invalid_grant
           try {
             const { alignMiniMaxFromLocal } = await import('./minimaxLocal.js');
-            if (alignMiniMaxFromLocal(account, (m) => logger.info('MINIMAX-GW', `${label} ${m}`))) {
+            if (alignMiniMaxFromLocal(account, (m) => logger.info('MINIMAX-GW', '{label} {msg}', { label, msg: m }))) {
               activeToken = account.token;
             }
           } catch {}
@@ -310,18 +327,22 @@ export async function handleGateway(req, res) {
           cooling.delete(account.id);
           upstream = await sendUpstream(activeToken);
         } catch (refErr) {
-          logger.warn('MINIMAX-GW', `${label} 凭据刷新失败: ${refErr.message}`);
+          logger.warn('MINIMAX-GW', '{label} 凭据刷新失败: {err}', { label, err: refErr.message });
         }
       }
     } catch (e) {
-      if (controller.signal.aborted) return;
+      if (clientAbort.signal.aborted) return;
       attempted.push({ account: label, ok: false, error: e.message });
       continue;
     }
 
     if (upstream.ok) {
       stats.lastAccount = label;
-      logger.info('MINIMAX-GW', `${label} 补全成功 (${upstream.status})`);
+      logger.info('MINIMAX-GW', '{label} 补全成功 ({status})', { label, status: upstream.status });
+      try {
+        const meta = JSON.parse(rawBody);
+        logger.debug('MINIMAX-GW', '请求详情：model={model} stream={stream} ua={ua}', { model: meta?.model || '-', stream: meta?.stream ? 'y' : 'n', ua: req.headers?.['user-agent'] || '-' });
+      } catch {}
 
       // 透传头（SSE / JSON）
       const forwardHeaders = {
@@ -343,7 +364,8 @@ export async function handleGateway(req, res) {
             }
           }
         } catch (e) {
-          logger.warn('MINIMAX-GW', `流式转发中断：${e.message}`);
+          // 客户端主动断开（点停止/换一句）属正常收尾，不是故障
+          logger.debug('MINIMAX-GW', '流式转发中断:{err}', { err: e.message });
         }
         res.end();
       } else {
@@ -358,13 +380,13 @@ export async function handleGateway(req, res) {
     if (upstream.status === 401) {
       markDead(account);
       attempted.push({ account: label, ok: false, error: 'Token 彻底失效 (401)，拉黑' });
-      logger.info('MINIMAX-GW', `${label} 凭据失效，拉黑`);
+      logger.info('MINIMAX-GW', '{label} 凭据失效,拉黑', { label });
       continue;
     }
     if (upstream.status === 429) {
       markCooling(account.id, ACCOUNT_COOLING_MS);
       attempted.push({ account: label, ok: false, error: '429 限流，冷却 5 分钟' });
-      logger.info('MINIMAX-GW', `${label} 429 限流，冷却 5 分钟`);
+      logger.info('MINIMAX-GW', '{label} 429 限流,冷却 5 分钟', { label });
       continue;
     }
 
@@ -372,6 +394,8 @@ export async function handleGateway(req, res) {
   }
 
   // 全部重试失败
+  const failedDetail = summarizeAttempts(attempted);
+  logger.warn('MINIMAX-GW', '全部 {n} 次尝试失败{detail}(下一请求自动重试)', { n: attempted.length, detail: failedDetail ? ':' + failedDetail : '' });
   res.writeHead(502, { 'Content-Type': 'application/json' });
   res.end(JSON.stringify({
     error: '所有 MiniMax 账号均调用失败',

package/src/minimaxLocal.js

@@ -49,6 +49,44 @@ function writeJson(file, data) {
   fs.writeFileSync(file, JSON.stringify(data, null, 2), 'utf8');
 }
 
+/**
+ * recordKey → uid 的小缓存。
+ *
+ * 为什么需要：auth.json 的 record 只有 accessToken / refreshToken / clientId 这些，
+ * 稳定 uid 只能靠 profile 接口拿；profile 偶发失败时（离线 / 接口抖动），
+ * 「客户端当前是哪个账号」就没法判断了，缓存一份兜底。
+ *
+ * 注意：缓存**只对 auth.json 里仍然存在的 record 生效**（见 currentMiniMaxUid）。
+ * 客户端登出后 records 为空，此时若还回落到缓存，面板会把某个账号一直标成
+ * 「客户端当前」——这正是「客户端明明没登录却显示已登录」的来源，所以读的时候必须
+ * 与当前 record 集合求交集，不能无条件回落。
+ */
+function readUidCache() {
+  return readJson(minimaxUidCachePath()) || {};
+}
+
+/** 写入 uid 缓存，并顺手丢掉 auth.json 里已经不存在的 record（防止缓存无限膨胀 / 陈旧） */
+function writeUidCache(recordKey, uid) {
+  if (!recordKey || !uid) return;
+  try {
+    const cache = readUidCache();
+    if (cache[recordKey] === String(uid)) return;
+    cache[recordKey] = String(uid);
+    const live = liveRecordKeys();
+    if (live) for (const k of Object.keys(cache)) if (!live.has(k)) delete cache[k];
+    writeJson(minimaxUidCachePath(), cache);
+  } catch {
+    // 缓存写失败不影响调用方
+  }
+}
+
+/** auth.json 里当前仍有 accessToken 的 recordKey 集合；读不到（文件缺失/损坏）返回 null */
+function liveRecordKeys() {
+  const authData = readJson(minimaxAuthPath());
+  if (!authData?.records) return null;
+  return new Set(Object.keys(authData.records).filter((k) => authData.records[k]?.accessToken));
+}
+
 /**
  * 寻找 MiniMax Code.exe 安装路径
  */
@@ -115,18 +153,10 @@ export async function liveToAccount() {
     // profile 失败不影响返回基础账号信息
   }
 
-  // auth.json 记录没有稳定 uid 字段，token 又高频轮换：
-  // 把 profile 解析出的 uid 按 authRecordKey 缓存，供 currentMiniMaxUid 离线比对。
-  const cached = readJson(minimaxUidCachePath()) || {};
-  const uid = profile?.userId || record.subject || record.accountId || cached[recordKey] || null;
-  if (profile?.userId && cached[recordKey] !== profile.userId) {
-    cached[recordKey] = profile.userId;
-    try {
-      writeJson(minimaxUidCachePath(), cached);
-    } catch {
-      // 缓存写失败不影响本次返回
-    }
-  }
+  // auth.json 的记录没有稳定 uid 字段，token 又高频轮换，profile 偶发失败时无处可查 ——
+  // 用 recordKey 把 uid 记住，供 currentMiniMaxUid 离线比对（见 minimaxUidCachePath 注释）。
+  const uid = profile?.userId || record.subject || record.accountId || readUidCache()[recordKey] || null;
+  if (uid) writeUidCache(recordKey, uid);
   const name = profile?.name || (uid ? `MiniMax_${String(uid).slice(-6)}` : 'MiniMax Code');
 
   return {
@@ -139,7 +169,10 @@ export async function liveToAccount() {
     email: profile?.email || null,
     source: 'local-app',
     meta: {
-      authRecordKey: recordKey,
+      // 不写 authRecordKey：它是「这条账号绑定本机客户端凭据链」的开关，一旦挂上，
+      // 该账号刷新前就会去 auth.json 重读 refreshToken（可能会被别的账号的链顶掉）、
+      // 刷新后还会回写 auth.json。本机导入/浏览器登录混用时曾因此让两个账号共用同一条链
+      // 互相作废，故这里只留来源标记，链的绑定交给 alignMiniMaxFromLocal 按 uid 判断。
       clientId: record.clientId,
       scopes: record.scopes,
       capturedAt: new Date().toISOString(),
@@ -149,7 +182,11 @@ export async function liveToAccount() {
 
 /**
  * 获取当前登录的 UID。
- * 优先用 record 自带字段；没有则按 authRecordKey 命中 uid 缓存（token 会轮换，uid 不会）。
+ * 优先用 record 自带字段；没有则按 recordKey 命中 uid 缓存（token 会轮换，uid 不会）。
+ *
+ * records 为空（客户端从未登录 / 已登出）时一律返回 null——绝不回落到缓存。
+ * 回落的代价是：客户端登出后 uid 缓存还留着，面板会继续把那个旧账号标成
+ * 「客户端当前」，看起来像登出没生效。
  */
 export function currentMiniMaxUid() {
   const authFile = minimaxAuthPath();
@@ -160,8 +197,7 @@ export function currentMiniMaxUid() {
   const record = authData.records[recordKey];
   const own = record?.subject || record?.accountId;
   if (own) return String(own);
-  const cached = readJson(minimaxUidCachePath());
-  return cached?.[recordKey] || null;
+  return readUidCache()[recordKey] || null;
 }
 
 /**
@@ -209,8 +245,17 @@ export function alignMiniMaxFromLocal(account, log) {
   const key = account?.meta?.authRecordKey;
   if (!key) return false;
   try {
+    // 归属校验：本机客户端同一时刻只登录一个账号，auth.json 里那条 record 属于**它**，
+    // 不一定属于调用方这个账号。若两个账号（如「本机导入」与「浏览器登录」）因为历史原因
+    // 挂了同一个 authRecordKey，不校验就会拿别人的链去刷新——两个账号共用一次性 refreshToken，
+    // 必然互相作废（invalid_grant）。uid 对不上就认定不是本账号的链，直接跳过对齐。
     const rec = readMiniMaxRecord(key);
     if (!rec?.refreshToken || rec.refreshToken === account.refreshToken) return false;
+    const recUid = rec.subject || rec.accountId || readUidCache()[key] || null;
+    if (recUid && account.uid && String(recUid) !== String(account.uid)) {
+      log?.('本机客户端当前登录的是另一个 MiniMax 账号，跳过凭据对齐（避免两条链互相作废）');
+      return false;
+    }
     account.refreshToken = rec.refreshToken;
     if (rec.accessToken) account.token = rec.accessToken;
     if (rec.expiresAtMs) account.expiresAt = new Date(rec.expiresAtMs).toISOString();

package/src/mirasimClient.js

@@ -8,6 +8,7 @@
 
 import { fetchJsonRace } from './zcodeClient.js';
 import { FETCH_TIMEOUT_MS } from './constants.js';
+import { withRefreshDedupe } from './refreshGuard.js';
 
 const AUTH_ME_URL = 'https://auth.mirasim.ai/auth/me';
 const RELAY_LIMITS_URL = 'https://relay.mirasim.ai/v1/limits';
@@ -64,7 +65,11 @@ async function withToken(account, fn, ctx) {
   let token = account.token;
   let refreshed = false;
   const doRefresh = async () => {
-    const creds = await refreshMirasimToken(account);
+    // 并发互斥 + 失效链熔断：与 minimax / workbuddy 共用 refreshGuard
+    const creds = await withRefreshDedupe(account, refreshMirasimToken, {
+      deadMessage: 'mirasim 凭据链已被服务端作废，等待重新登录',
+      deadNotice: 'mirasim 凭据链已失效，将不再自动重试（重新登录或重新导入该账号后自动恢复）',
+    });
     account.token = creds.token;
     account.refreshToken = creds.refreshToken;
     if (creds.expiresAt) account.expiresAt = creds.expiresAt;