creditdaddy 1.3.0 → 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 { // 落盘失败不拖累主流程
   }
 }
@@ -51,14 +67,21 @@ function ts() {
     + ' ' + pad(d.getHours()) + ':' + pad(d.getMinutes()) + ':' + pad(d.getSeconds());
 }
 
-/** 把一份已关闭的日志 gzip 成 .log.gz（此时流已 flush、fd 已释放，可安全同步读），并按保留期清理过期归档 */
+/**
+ * 把一份已关闭的日志 gzip 成 .log.gz（此时流已 flush、fd 已释放，可安全同步读），并按保留期清理过期归档。
+ *
+ * ⚠️ 压缩后**截断**原文件而不是删除它：同一天的文件可能被另一个实例（前台 daemon /
+ * 桌面版）以 O_APPEND 持有同一个 fd。删掉原文件后，POSIX 上它的后续写入会落进一个
+ * 已无链接的 inode —— 别的实例还在正常跑，日志却静默消失。截断成 0 字节后 O_APPEND
+ * 会从 0 重新追加，同一个 inode、同一批数据，谁都不会丢。
+ */
 function gzipAndCleanup(file) {
   try {
     if (fsSync.existsSync(file)) {
       const raw = fsSync.readFileSync(file);
       if (raw.length) {
         fsSync.writeFileSync(file + '.gz', zlib.gzipSync(raw));
-        fsSync.unlinkSync(file);
+        fsSync.truncateSync(file, 0);
       }
     }
   } catch {}
@@ -74,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;
@@ -86,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);
@@ -96,26 +120,144 @@ 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),
 };
 
+/**
+ * 把各账号的失败结论压缩成「失败类型×次数」摘要，写进“全部失败”日志——
+ * 网络抖动 / 验证码 / 额度 / 限流 / 拉黑 一眼可辨，不用再靠“有没有伴随 3012”去反推。
+ * 三处网关共用同一口径；未知错误归入「上游错误」。
+ */
+export function summarizeAttempts(attempted) {
+  if (!Array.isArray(attempted) || !attempted.length) return '';
+  const buckets = new Map();
+  for (const a of attempted) {
+    const err = String(a && a.error ? a.error : '未知错误');
+    let key;
+    if (a && a.captcha) key = '验证码被拒';
+    else if (/验证码/.test(err)) key = '验证码被拒';
+    else if (/拉黑|凭据失效|JWT|Token 彻底失效|401/.test(err)) key = '账号拉黑';
+    else if (/额度耗尽|额度不足|已打标/.test(err)) key = '额度耗尽';
+    else if (/额度/.test(err)) key = '额度瞬时拒绝';
+    else if (/429|限流/.test(err)) key = '429 限流';
+    else if (/超时|timeout|timed out|连接|ECONN|ENOTFOUND|EAI_AGAIN|ETIMEDOUT|terminated|aborted|fetch failed|网络|建立事件流失败/.test(err)) key = '网络错误';
+    else key = '上游错误';
+    buckets.set(key, (buckets.get(key) || 0) + 1);
+  }
+  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) {
-  const lines = tag ? ring.filter((l) => l.tag === tag) : ring;
-  return lines.slice(-limit);
+  // tag=null 是面板「运行日志」：网关调用日志（*-GW）刷屏快、口径不同，
+  // 只在自己的标签页里展示，不混进运行日志；显式传 tag 的查询不受影响。
+  const lines = tag ? ring.filter((l) => l.tag === tag) : ring.filter((l) => !(l.tag || '').endsWith('-GW'));
+  return lines.slice(-limit).map((l) => (l.key ? { ...l, msg: t(l.key, localizeArgs(l.args)) } : l));
 }
 
-/** 测试收尾 / 进程退出用：关闭当前归档流，落盘后 gzip 归档并清理过期文件 */
-export function closeArchiveStream() {
-  if (archiveStream) {
-    const prev = archiveStream;
-    const prevFile = path.join(archiveDir, `daemon-${archiveDay}.log`);
-    archiveStream = null;
-    prev.on('error', () => {});
-    prev.on('close', () => gzipAndCleanup(prevFile));
-    prev.end();
+
+/**
+ * 读取结构化归档（.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;
+}
+
+/**
+ * 测试收尾 / 进程退出用：关闭当前归档流，落盘后 gzip 归档并清理过期文件。
+ *
+ * 返回 Promise，等流真正 close（gzip 已完成）才 resolve —— 优雅退出路径紧接着就要
+ * process.exit()，不等的话回调根本没机会跑，今天的日志既不落盘也不归档。
+ * 调用方不 await（测试里就是）也完全兼容，只是没人等它。
+ */
+export function closeArchiveStream() {
+  const prev = archiveStream;
+  const prevJ = jsonlStream;
+  const prevFile = archiveDay ? path.join(archiveDir, `daemon-${archiveDay}.log`) : null;
+  const prevJFile = jsonlFile;
+  archiveStream = null;
+  jsonlStream = null;
   archiveDay = null;
+  const closeOne = (stream, file) => new Promise((resolve) => {
+    if (!stream) return resolve();
+    let settled = false;
+    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?.();
+    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';
@@ -25,6 +26,14 @@ export const SIGNIN_STATUS_URL = `${MINIMAX_AGENT_BASE}/minimax-cloud/api/v1/sig
 export const SIGNIN_CLAIM_URL = `${MINIMAX_AGENT_BASE}/minimax-cloud/api/v1/signin/claim?timezone_offset=28800&is_desktop=1&client=desktop`;
 export const TOKEN_REFRESH_URL = `${MINIMAX_ACCOUNT_BASE}/oauth2/token`;
 
+/** 时间戳宽容转换（口径同 traeClient.iso）：≤1e11 视为秒，否则视为毫秒；0/无效 → null */
+function isoMs(v) {
+  const n = Number(v);
+  if (!Number.isFinite(n) || n <= 0) return null;
+  const d = new Date(n < 1e11 ? n * 1000 : n);
+  return Number.isFinite(d.getTime()) && d.getUTCFullYear() < 9000 ? d.toISOString() : null;
+}
+
 function authHeaders(token) {
   const t = token?.startsWith('Bearer ') ? token : `Bearer ${String(token || '').trim()}`;
   return {
@@ -77,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 = {}) {
@@ -94,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,
+  });
 }
 
 /**
@@ -250,7 +255,8 @@ export function normalizeMiniMaxQuota(data) {
     // 顶层不设 unit：面板 creditSum 用「有 unit 即异单位」来排除合计，
     // MiniMax 与 Qoder / Trae 同为「积分」口径，必须计入剩余积分合计。
     plan: data.plan_name || (data.is_pro_builder ? 'Pro' : '免费版'),
-    planExpiresAt: data.expires_at ? new Date(data.expires_at * 1000).toISOString() : null,
+    // expires_at 是毫秒时间戳：再乘 1000 会显示成 58729 年（实测免费版返回 0，按无到期处理）
+    planExpiresAt: isoMs(data.expires_at),
     parts,
     empty: total <= 0,
   };