creditdaddy 1.3.2 → 1.4.0

package/src/i18n.js

@@ -0,0 +1,47 @@
+/** 轻量国际化:以中文原文为 key,缺翻译时回退中文。字典位于 src/i18n/<locale>.json。 */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export const LOCALES = ['zh-CN', 'zh-TW', 'en', 'ja', 'ko'];
+const DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), 'i18n');
+const cache = new Map();
+
+export function normalizeLocale(v) {
+  const s = String(v || '').trim();
+  return LOCALES.includes(s) ? s : 'zh-CN';
+}
+
+function dictFor(locale) {
+  if (locale === 'zh-CN') return {};
+  if (!cache.has(locale)) {
+    try {
+      cache.set(locale, JSON.parse(fs.readFileSync(path.join(DIR, `${locale}.json`), 'utf8')));
+    } catch {
+      cache.set(locale, {});
+    }
+  }
+  return cache.get(locale);
+}
+
+export async function loadDict(locale) {
+  return dictFor(normalizeLocale(locale));
+}
+
+let current = 'zh-CN';
+
+export function setLocale(v) {
+  current = normalizeLocale(v);
+}
+
+export function getLocale() {
+  return current;
+}
+
+/** t('已连接 {n} 个账号', { n: 2 }) → 按当前语言取译文,再替换 {占位符} */
+export function t(text, vars) {
+  const s = dictFor(current)[text] ?? text;
+  if (!vars) return s;
+  return s.replace(/\{(\w+)\}/g, (m, k) => (k in vars ? String(vars[k]) : m));
+}

package/src/logger.js

@@ -8,6 +8,8 @@ import fsSync from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
 import zlib from 'node:zlib';
+import { t } from './i18n.js';
+import { PROVIDER_LABEL } from './constants.js';
 
 const ARCHIVE_RETENTION_DAYS = 7;   // .log.gz 归档保留天数，更早的自动清理
 
@@ -21,6 +23,8 @@ try {
 
 let archiveDay = null;
 let archiveStream = null;
+let jsonlStream = null;
+let jsonlFile = null;
 
 function archiveLine(line) {
   if (!archiveDir) return;
@@ -36,10 +40,22 @@ function archiveLine(line) {
         prev.on('close', () => gzipAndCleanup(prevFile));
         prev.end();
       }
+      if (jsonlStream) {
+        const prevj = jsonlStream;
+        const prevjFile = jsonlFile;
+        jsonlStream = null;
+        prevj.on('error', () => {});
+        prevj.on('close', () => gzipAndCleanup(prevjFile));
+        prevj.end();
+      }
       archiveStream = fsSync.createWriteStream(path.join(archiveDir, `daemon-${day}.log`), { flags: 'a' });
+      jsonlFile = path.join(archiveDir, `daemon-${day}.jsonl`);
+      jsonlStream = fsSync.createWriteStream(jsonlFile, { flags: 'a' });
       archiveDay = day;
     }
     archiveStream.write('[' + line.at + '] ' + line.level.toUpperCase() + ' [' + line.tag + '] ' + line.msg + '\n');
+    // 结构化副行（JSONL）：key+args 原样落盘，读取侧按当前语言重渲染（历史也能切语言）
+    jsonlStream.write(JSON.stringify({ at: line.at, level: line.level, tag: line.tag, msg: line.msg, key: line.key, args: line.args }) + '\n');
   } catch { // 落盘失败不拖累主流程
   }
 }
@@ -81,7 +97,7 @@ function cleanupArchive() {
     cutoff.setDate(cutoff.getDate() - ARCHIVE_RETENTION_DAYS);
     cutoff.setHours(0, 0, 0, 0);
     for (const name of fsSync.readdirSync(archiveDir)) {
-      const m = /^daemon-(\d{4}-\d{2}-\d{2})\.log(\.gz)?$/.exec(name);
+      const m = /^daemon-(\d{4}-\d{2}-\d{2})\.(?:log|jsonl)(\.gz)?$/.exec(name);
       if (!m) continue;   // 只动本 daemon 的归档文件，不碰目录里其他文件
       const f = path.join(archiveDir, name);
       let fileDay;
@@ -93,8 +109,9 @@ function cleanupArchive() {
   } catch {}
 }
 
-export function log(level, tag, msg) {
-  const line = { at: ts(), level, tag, msg: String(msg) };
+export function log(level, tag, msg, args) {
+  const rendered = t(String(msg), args);
+  const line = { at: ts(), level, tag, msg: rendered, key: args ? String(msg) : null, args: args || null };
   ring.push(line);
   if (ring.length > RING_SIZE) ring.shift();
   archiveLine(line);
@@ -103,10 +120,10 @@ export function log(level, tag, msg) {
 }
 
 export const logger = {
-  info: (tag, msg) => log('info', tag, msg),
-  warn: (tag, msg) => log('warn', tag, msg),
-  error: (tag, msg) => log('error', tag, msg),
-  debug: (tag, msg) => log('debug', tag, msg),
+  info: (tag, msg, args) => log('info', tag, msg, args),
+  warn: (tag, msg, args) => log('warn', tag, msg, args),
+  error: (tag, msg, args) => log('error', tag, msg, args),
+  debug: (tag, msg, args) => log('debug', tag, msg, args),
 };
 
 /**
@@ -133,11 +150,86 @@ export function summarizeAttempts(attempted) {
   return [...buckets.entries()].map(([k, n]) => `${k}×${n}`).join('、');
 }
 
+/**
+ * 运行期拼出的复合参数（如「[WorkBuddy 国内版] 账号名」）不可能整串进字典（账号名千变万化），
+ * 其中已知的产品 / 区域标签按当前语言做子串替换，其余字段原样保留。
+ */
+// 除产品线标签外，失败摘要的桶标签（summarizeAttempts 产出，记进 {detail} 参数，形如「账号拉黑×2」）
+// 同样是运行期复合串，整串无法进词典，按子串替换。
+const ATTEMPT_BUCKETS = ['验证码被拒', '账号拉黑', '额度耗尽', '额度瞬时拒绝', '429 限流', '网络错误', '上游错误'];
+
+function localizeEmbedded(text) {
+  let out = text;
+  for (const zh of [...Object.values(PROVIDER_LABEL), ...ATTEMPT_BUCKETS]) {
+    if (!out.includes(zh)) continue;
+    const tv = t(zh);
+    if (tv !== zh) out = out.split(zh).join(tv);
+  }
+  return out;
+}
+
+/** 带运行时数字的既有消息（连签 11 天 / 第 1 天 +400 积分）：按模式还原成模板再按当前语言渲染 */
+const ARG_PATTERNS = [
+  [/^今日已签（连签 (\d+) 天）$/, '今日已签（连签 {n} 天）', (m) => ({ n: m[1] })],
+  [/^今日第 (\d+) 天已签到（([\d.]+) \+ ([\d.]+) 积分）$/, '今日第 {d} 天已签到（{a} + {b} 积分）', (m) => ({ d: m[1], a: m[2], b: m[3] })],
+  [/^签到成功第 (\d+) 天（\+(\d+) 积分）$/, '签到成功第 {d} 天（+{p} 积分）', (m) => ({ d: m[1], p: m[2] })],
+  [/^今日已领取（\+(\d+) 积分）$/, '今日已领取（+{p} 积分）', (m) => ({ p: m[1] })],
+  [/^本机今日国际版额度已由「(.+)」领取（Qoder 每台设备每天限领一次）$/, '本机今日国际版额度已由「{name}」领取（Qoder 每台设备每天限领一次）', (m) => ({ name: localizeEmbedded(m[1]) })],
+];
+
+/** 字符串参数的三级翻译：整串精确 → 模式还原模板 → 子串标签替换 */
+function localizeArgString(v, ctx) {
+  const tv = t(v, ctx);
+  if (tv !== v) return tv;
+  for (const [re, tpl, vars] of ARG_PATTERNS) {
+    const m = re.exec(v);
+    if (m) return t(tpl, vars(m));
+  }
+  return localizeEmbedded(v);
+}
+
+function localizeArgs(args) {
+  if (!args) return args;
+  const loc = {};
+  for (const [k, v] of Object.entries(args)) loc[k] = typeof v === 'string' ? localizeArgString(v, args) : v;
+  const out = {};
+  for (const [k, v] of Object.entries(args)) out[k] = typeof v === 'string' ? localizeArgString(v, loc) : v;
+  return out;
+}
+
 export function getLogs(limit = 100, tag = null) {
   // tag=null 是面板「运行日志」：网关调用日志（*-GW）刷屏快、口径不同，
   // 只在自己的标签页里展示，不混进运行日志；显式传 tag 的查询不受影响。
   const lines = tag ? ring.filter((l) => l.tag === tag) : ring.filter((l) => !(l.tag || '').endsWith('-GW'));
-  return lines.slice(-limit);
+  return lines.slice(-limit).map((l) => (l.key ? { ...l, msg: t(l.key, localizeArgs(l.args)) } : l));
+}
+
+
+/**
+ * 读取结构化归档（.jsonl；缺省读当日、最多 limit 条）并按当前语言重渲染。
+ * 旧版本没有 .jsonl 时返回 []，调用方静默回退到环形缓冲。
+ * 同时兼容已 gzip 的当日归档（.jsonl.gz）。
+ */
+export function readArchiveJsonl({ day = null, limit = 2000 } = {}) {
+  if (!archiveDir) return [];
+  const d = day || ts().slice(0, 10);
+  const file = path.join(archiveDir, `daemon-${d}.jsonl`);
+  const gz = file + '.gz';
+  let raw = '';
+  try {
+    raw = fsSync.existsSync(file) ? fsSync.readFileSync(file, 'utf8') : '';
+    if (!raw && fsSync.existsSync(gz)) raw = zlib.gunzipSync(fsSync.readFileSync(gz)).toString('utf8');
+  } catch { return []; }
+  if (!raw) return [];
+  const lines = raw.split('\n').filter(Boolean).slice(-Math.max(1, Number(limit) || 2000));
+  const out = [];
+  for (const ln of lines) {
+    try {
+      const e = JSON.parse(ln);
+      out.push({ at: e.at, level: e.level, tag: e.tag, msg: e.key ? t(e.key, localizeArgs(e.args)) : e.msg });
+    } catch {}
+  }
+  return out;
 }
 
 /**
@@ -148,19 +240,24 @@ export function getLogs(limit = 100, tag = null) {
  * 调用方不 await（测试里就是）也完全兼容，只是没人等它。
  */
 export function closeArchiveStream() {
-  if (!archiveStream) return Promise.resolve();
   const prev = archiveStream;
-  const prevFile = path.join(archiveDir, `daemon-${archiveDay}.log`);
+  const prevJ = jsonlStream;
+  const prevFile = archiveDay ? path.join(archiveDir, `daemon-${archiveDay}.log`) : null;
+  const prevJFile = jsonlFile;
   archiveStream = null;
+  jsonlStream = null;
   archiveDay = null;
-  return new Promise((resolve) => {
+  const closeOne = (stream, file) => new Promise((resolve) => {
+    if (!stream) return resolve();
     let settled = false;
-    const done = () => { if (!settled) { settled = true; resolve(); } };
-    prev.on('error', done);
-    prev.on('close', () => { gzipAndCleanup(prevFile); done(); });
-    // 兜底：万一 close 事件不来（fd 被外部占住），不让退出流程永远挂在这里
-    const timer = setTimeout(done, 2000);
+    const finish = (gzip) => { if (!settled) { settled = true; if (gzip) gzipAndCleanup(file); resolve(); } };
+    stream.on('error', () => finish(false));
+    // 只等 close 事件收尾（gzip 也在这里做）：end 的回调在 finish 阶段就触发，
+    // 那时 close 还没来、.gz 还没生成——await 完断言会看到对象不齐（测试 #3 逮过）
+    stream.on('close', () => finish(true));
+    const timer = setTimeout(() => finish(false), 2000);  // 兜底：close 不来不挂死
     timer.unref?.();
-    prev.end(done);
+    stream.end();
   });
+  return Promise.all([closeOne(prev, prevFile), closeOne(prevJ, prevJFile)]);
 }

package/src/minimaxClient.js

@@ -13,6 +13,7 @@
  */
 
 import { fetchJsonRace } from './zcodeClient.js';
+import { withRefreshDedupe, refreshFpDead } from './refreshGuard.js';
 import { FETCH_TIMEOUT_MS } from './constants.js';
 
 export const MINIMAX_AGENT_BASE = 'https://agent.minimax.cn';
@@ -85,8 +86,10 @@ export async function refreshMiniMaxToken(refreshToken) {
 /**
  * 带自动刷新 401 重试的高阶调用。
  *
- * 刷新前若该账号来自本机导入（meta.authRecordKey），先从 ~/.minimax auth.json 重读该 record 的
- * 最新 refreshToken——本机客户端会独立轮换刷新，账号库快照可能已被服务端作废（invalid_grant）。
+ * 刷新前若该账号带有 meta.authRecordKey（绑定本机客户端凭据链，仅本机导入账号会有），
+ * 先从 ~/.minimax auth.json 重读该 record 的最新 refreshToken——本机客户端会独立轮换刷新，
+ * 账号库快照可能已被服务端作废（invalid_grant）。对齐时会校验 uid 归属，链不算本账号的则跳过
+ * （见 minimaxLocal.alignMiniMaxFromLocal）。
  * 刷新成功后经 ctx.onRefresh 回写账号库，并尝试安全回写 auth.json（见 minimaxLocal.writeMiniMaxAuth）。
  */
 export async function withMiniMaxAuth(account, fn, ctx = {}) {
@@ -102,44 +105,38 @@ export async function withMiniMaxAuth(account, fn, ctx = {}) {
 }
 
 /**
- * refreshToken 是一次性的、刷新即轮换：两个并发 401 拿同一个 refreshToken 去刷新，
- * 必然一个成功一个 invalid_grant。签到轮（checkin）与面板的额度查询互不知情，
- * 面板每 2 分钟刷一轮账号额度，很容易和 2 小时一次的签到轮撞上。
- * 用 in-flight 表把同一账号的并发刷新合并成一次，后到者直接用刷新出来的新 token 重试。
+ * 并发互斥 + 失效链熔断已提升到 src/refreshGuard.js —— workbuddy / mirasim 复用同一守卫。
+ * MiniMax 特有的点：刷新前先 alignMiniMaxFromLocal 对齐本机客户端最新链（客户端会轮换）。
  */
-const refreshInFlight = new Map();
-
 function refreshAccountToken(account, ctx = {}) {
-  const key = account.id || account.token;
-  const inflight = refreshInFlight.get(key);
-  if (inflight) return inflight;
-  const p = (async () => {
-    // 本机导入账号：刷新前对齐客户端最新的 refreshToken，避免用陈旧快照刷新触发 invalid_grant
+  return withRefreshDedupe(account, async (a) => {
     try {
       const { alignMiniMaxFromLocal } = await import('./minimaxLocal.js');
-      alignMiniMaxFromLocal(account, ctx.log);
+      alignMiniMaxFromLocal(a, ctx.log);
     } catch {}
     ctx.log?.('MiniMax token 已过期，正在自动刷新…');
     try {
-      const refreshed = await refreshMiniMaxToken(account.refreshToken);
+      const refreshed = await refreshMiniMaxToken(a.refreshToken);
       const expiresAt = new Date(Date.now() + refreshed.expiresIn * 1000).toISOString();
       const creds = {
         token: refreshed.accessToken,
         refreshToken: refreshed.refreshToken,
         expiresAt,
       };
-      account.token = creds.token;
-      account.refreshToken = creds.refreshToken;
-      account.expiresAt = expiresAt;
+      a.token = creds.token;
+      a.refreshToken = creds.refreshToken;
+      a.expiresAt = expiresAt;
       await ctx.onRefresh?.(creds);
       return creds;
     } catch (refErr) {
       ctx.log?.(`MiniMax token 自动刷新失败: ${refErr.message}`);
       throw refErr;
     }
-  })().finally(() => refreshInFlight.delete(key));
-  refreshInFlight.set(key, p);
-  return p;
+  }, {
+    deadMessage: 'MiniMax 凭据链已被服务端作废，等待重新登录',
+    deadNotice: 'MiniMax 凭据链已失效，将不再自动重试（重新登录或重新导入该账号后自动恢复）',
+    log: ctx.log,
+  });
 }
 
 /**

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,7 +17,8 @@ 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, summarizeAttempts } 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;
@@ -45,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,
@@ -80,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');
@@ -126,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() {
@@ -178,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();
   });
 }
@@ -284,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 {}
@@ -313,7 +327,7 @@ 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) {
@@ -324,7 +338,11 @@ export async function handleGateway(req, res) {
 
     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 = {
@@ -347,7 +365,7 @@ export async function handleGateway(req, res) {
           }
         } catch (e) {
           // 客户端主动断开（点停止/换一句）属正常收尾，不是故障
-          logger.debug('MINIMAX-GW', `流式转发中断：${e.message}`);
+          logger.debug('MINIMAX-GW', '流式转发中断:{err}', { err: e.message });
         }
         res.end();
       } else {
@@ -362,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;
     }
 
@@ -377,7 +395,7 @@ export async function handleGateway(req, res) {
 
   // 全部重试失败
   const failedDetail = summarizeAttempts(attempted);
-  logger.warn('MINIMAX-GW', `全部 ${attempted.length} 次尝试失败${failedDetail ? '：' + failedDetail : ''}（下一请求自动重试）`);
+  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 账号均调用失败',