creditdaddy 1.2.0 → 1.3.2

package/src/logger.js

@@ -3,10 +3,13 @@
 const RING_SIZE = 300;
 const ring = [];
 
-// ─── 按日期归档：logs/daemon-YYYY-MM-DD.log（跨天自动换文件） ───
+// ─── 按日期归档：logs/daemon-YYYY-MM-DD.log（跨天自动换文件，历史自动 gzip） ───
 import fsSync from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
+import zlib from 'node:zlib';
+
+const ARCHIVE_RETENTION_DAYS = 7;   // .log.gz 归档保留天数，更早的自动清理
 
 let archiveDir = null;
 try {
@@ -24,7 +27,15 @@ function archiveLine(line) {
   try {
     const day = line.at.slice(0, 10);
     if (archiveDay !== day || !archiveStream) {
-      if (archiveStream) archiveStream.end();
+      if (archiveStream) {
+        // 跨天 / 重启：把上一份流关闭，待其落盘完成（close 事件）后再 gzip
+        const prev = archiveStream;
+        const prevFile = path.join(archiveDir, `daemon-${archiveDay}.log`);
+        archiveStream = null;
+        prev.on('error', () => {});
+        prev.on('close', () => gzipAndCleanup(prevFile));
+        prev.end();
+      }
       archiveStream = fsSync.createWriteStream(path.join(archiveDir, `daemon-${day}.log`), { flags: 'a' });
       archiveDay = day;
     }
@@ -40,6 +51,48 @@ function ts() {
     + ' ' + pad(d.getHours()) + ':' + pad(d.getMinutes()) + ':' + pad(d.getSeconds());
 }
 
+/**
+ * 把一份已关闭的日志 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.truncateSync(file, 0);
+      }
+    }
+  } catch {}
+  cleanupArchive();
+}
+
+/** 清理超过保留期的 .log.gz 归档（以及残留的旧 .log），按文件名里的日期判断，不依赖 mtime */
+function cleanupArchive() {
+  if (!archiveDir) return;
+  try {
+    // 保留期按「文件名日期距今 N 天」算：今天与最近 7 天的归档都保留
+    const cutoff = new Date();
+    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);
+      if (!m) continue;   // 只动本 daemon 的归档文件，不碰目录里其他文件
+      const f = path.join(archiveDir, name);
+      let fileDay;
+      try { fileDay = new Date(m[1] + 'T00:00:00'); } catch { continue; }
+      if (fileDay.getTime() < cutoff.getTime()) {
+        try { fsSync.unlinkSync(f); } catch {}
+      }
+    }
+  } catch {}
+}
+
 export function log(level, tag, msg) {
   const line = { at: ts(), level, tag, msg: String(msg) };
   ring.push(line);
@@ -56,13 +109,58 @@ export const logger = {
   debug: (tag, msg) => log('debug', tag, msg),
 };
 
-export function getLogs(limit = 100) {
-  return ring.slice(-limit);
+/**
+ * 把各账号的失败结论压缩成「失败类型×次数」摘要，写进“全部失败”日志——
+ * 网络抖动 / 验证码 / 额度 / 限流 / 拉黑 一眼可辨，不用再靠“有没有伴随 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('、');
+}
+
+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);
 }
 
-/** 测试收尾用：归档流的句柄不关，测试进程的临时目录在 Windows 上删不掉 */
+/**
+ * 测试收尾 / 进程退出用：关闭当前归档流，落盘后 gzip 归档并清理过期文件。
+ *
+ * 返回 Promise，等流真正 close（gzip 已完成）才 resolve —— 优雅退出路径紧接着就要
+ * process.exit()，不等的话回调根本没机会跑，今天的日志既不落盘也不归档。
+ * 调用方不 await（测试里就是）也完全兼容，只是没人等它。
+ */
 export function closeArchiveStream() {
-  try { archiveStream?.end(); } catch {}
+  if (!archiveStream) return Promise.resolve();
+  const prev = archiveStream;
+  const prevFile = path.join(archiveDir, `daemon-${archiveDay}.log`);
   archiveStream = null;
   archiveDay = null;
+  return new Promise((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);
+    timer.unref?.();
+    prev.end(done);
+  });
 }

package/src/minimaxAuth.js

@@ -0,0 +1,127 @@
+/**
+ * MiniMax Code 浏览器登录 — 官方 OAuth 设备码授权（RFC 8628 + S256 PKCE），
+ * 与客户端「扫码登录」同一协议，任何浏览器 / 桌面版隐私窗口都能完成，无需 zcode:// 式本地回调。
+ *
+ *   1. POST https://account.minimax.cn/oauth2/device/code
+ *      {client_id:mcode-public, scope:agent.default, audience:agent-backend,
+ *       code_challenge:<S256>, code_challenge_method:S256}
+ *      → {device_code, user_code, verification_uri_complete, expires_in:300, interval:3}
+ *   2. 用户在浏览器打开 verification_uri_complete（account.minimax.cn/oauth-authorize?user_code=…）登录授权
+ *   3. POST https://account.minimax.cn/oauth2/token
+ *      {grant_type:urn:ietf:params:oauth:grant-type:device_code, device_code, client_id, code_verifier}
+ *      → 未授权时 400 authorization_pending / slow_down（继续等）；授权后 200
+ *        {access_token, refresh_token, expires_in, …}
+ *
+ * 与「本机导入」的关键区别：设备码登录拿到的是**独立 loginEpoch** 的一条新 refresh token 链，
+ * 不与本机 ~/.minimax 客户端共用凭据，因此 CreditDaddy 自行刷新不会作废客户端的 token（消除轮换互斥）。
+ * 故本流程**绝不回写** auth.json，device 账号自持凭据链。
+ */
+
+import crypto from 'node:crypto';
+import { fetchJsonRace } from './zcodeClient.js';
+import { FETCH_TIMEOUT_MS } from './constants.js';
+import { MINIMAX_ACCOUNT_BASE, fetchMiniMaxProfile } from './minimaxClient.js';
+
+const DEVICE_CODE_URL = `${MINIMAX_ACCOUNT_BASE}/oauth2/device/code`;
+const TOKEN_URL = `${MINIMAX_ACCOUNT_BASE}/oauth2/token`;
+const CLIENT_ID = 'mcode-public';
+const SCOPE = 'agent.default';
+const AUDIENCE = 'agent-backend';
+const DEVICE_GRANT = 'urn:ietf:params:oauth:grant-type:device_code';
+
+function base64Url(buf) {
+  return buf.toString('base64').replace(/=/g, '').replace(/\+/g, '-').replace(/\//g, '_');
+}
+
+async function postForm(url, fields) {
+  const form = new URLSearchParams();
+  for (const [k, v] of Object.entries(fields)) form.set(k, v);
+  const res = await fetchJsonRace(url, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/x-www-form-urlencoded', Accept: 'application/json' },
+    body: form.toString(),
+    timeoutMs: FETCH_TIMEOUT_MS,
+  });
+  const text = await res.text().catch(() => '');
+  let body = null;
+  try { body = text ? JSON.parse(text) : null; } catch {}
+  return { res, body, text };
+}
+
+/** 发起设备码授权，返回浏览器授权地址与轮询参数 */
+export async function startMiniMaxLogin() {
+  const verifier = base64Url(crypto.randomBytes(32));
+  const challenge = base64Url(crypto.createHash('sha256').update(verifier).digest());
+  const { res, body, text } = await postForm(DEVICE_CODE_URL, {
+    client_id: CLIENT_ID, scope: SCOPE, audience: AUDIENCE,
+    code_challenge: challenge, code_challenge_method: 'S256',
+  });
+  if (!res.ok || !body?.device_code || !body?.verification_uri_complete) {
+    throw new Error('MiniMax 设备码初始化失败：HTTP ' + res.status + (text ? ' ' + text.slice(0, 200) : ''));
+  }
+  const url = String(body.verification_uri_complete);
+  if (!url.startsWith('https://')) throw new Error('MiniMax 授权返回了非 https 地址');
+  return {
+    url,
+    expiresInMs: Math.max(60e3, (Number(body.expires_in) || 300) * 1000),
+    intervalMs: Math.max(2000, (Number(body.interval) || 3) * 1000),
+    data: { deviceCode: body.device_code, verifier, userCode: body.user_code || null },
+  };
+}
+
+/**
+ * 单次轮询：{status:'pending'} | {status:'ok', input}
+ * authorization_pending / slow_down 视为继续等待；其余错误抛出（终态失败）。
+ */
+export async function pollMiniMaxLogin(data) {
+  const { res, body, text } = await postForm(TOKEN_URL, {
+    grant_type: DEVICE_GRANT,
+    device_code: data.deviceCode,
+    client_id: CLIENT_ID,
+    code_verifier: data.verifier,
+  });
+
+  const errCode = body?.error;
+  if (res.status === 400 && (errCode === 'authorization_pending' || errCode === 'slow_down')) {
+    return { status: 'pending' };
+  }
+  if (errCode === 'expired_token') throw new Error('MiniMax 授权已超时，请重新发起');
+  if (errCode === 'access_denied') throw new Error('MiniMax 授权被拒绝');
+  if (!res.ok || !body?.access_token) {
+    throw new Error('MiniMax 授权失败：HTTP ' + res.status + (errCode ? ' ' + errCode : '') + (text ? ' ' + text.slice(0, 200) : ''));
+  }
+
+  const accessToken = String(body.access_token);
+  const refreshToken = body.refresh_token ? String(body.refresh_token) : null;
+  const expiresIn = Number(body.expires_in) || 3600;
+  const expiresAt = new Date(Date.now() + expiresIn * 1000).toISOString();
+
+  // best-effort 取资料补全 uid / 昵称 / 邮箱；失败不阻断（uid 为空则按 token 去重）
+  let profile = null;
+  try { profile = await fetchMiniMaxProfile(accessToken); } catch {}
+
+  const uid = profile?.userId || null;
+  const name = profile?.name || (uid ? `MiniMax_${String(uid).slice(-6)}` : null);
+
+  return {
+    status: 'ok',
+    input: {
+      provider: 'minimax',
+      token: accessToken,
+      refreshToken,
+      expiresAt,
+      uid: uid ? String(uid) : null,
+      name: name || profile?.email || null,
+      email: profile?.email || null,
+      source: 'browser',
+      meta: {
+        clientId: CLIENT_ID,
+        scopes: [SCOPE],
+        audience: AUDIENCE,
+        loginVia: 'device-code',
+        userCode: data.userCode || null,
+        capturedAt: new Date().toISOString(),
+      },
+    },
+  };
+}

package/src/minimaxClient.js

@@ -0,0 +1,339 @@
+/**
+ * MiniMax Code 服务端 API 客户端 — 用户信息、额度查询、每日签到与 Token 续期。
+ *
+ * 官方标准端点：
+ *   - 用户资料：GET https://agent.minimax.cn/matrix/api/v1/user/profile
+ *   - 额度查询：POST https://agent.minimax.cn/matrix/api/v1/commerce/get_membership_info
+ *   - 签到状态：GET https://agent.minimax.cn/minimax-cloud/api/v1/signin/status?timezone_offset=28800&is_desktop=1&client=desktop
+ *   - 签到领取：POST https://agent.minimax.cn/minimax-cloud/api/v1/signin/claim?timezone_offset=28800&is_desktop=1&client=desktop
+ *   - Token 续期：POST https://account.minimax.cn/oauth2/token
+ *
+ * 补全模型网关端点：
+ *   - Anthropic 兼容端点：POST https://agent.minimax.cn/mavis/api/v1/llm/v1/messages
+ */
+
+import { fetchJsonRace } from './zcodeClient.js';
+import { FETCH_TIMEOUT_MS } from './constants.js';
+
+export const MINIMAX_AGENT_BASE = 'https://agent.minimax.cn';
+export const MINIMAX_ACCOUNT_BASE = 'https://account.minimax.cn';
+export const MINIMAX_MESSAGES_URL = `${MINIMAX_AGENT_BASE}/mavis/api/v1/llm/v1/messages`;
+
+export const PROFILE_URL = `${MINIMAX_AGENT_BASE}/matrix/api/v1/user/profile`;
+export const MEMBERSHIP_URL = `${MINIMAX_AGENT_BASE}/matrix/api/v1/commerce/get_membership_info`;
+export const SIGNIN_STATUS_URL = `${MINIMAX_AGENT_BASE}/minimax-cloud/api/v1/signin/status?timezone_offset=28800&is_desktop=1&client=desktop`;
+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 {
+    Authorization: t,
+    Accept: 'application/json',
+  };
+}
+
+/**
+ * 刷新 MiniMax OAuth 凭据
+ * @param {string} refreshToken
+ * @returns {Promise<{accessToken: string, refreshToken: string, expiresIn: number}>}
+ */
+export async function refreshMiniMaxToken(refreshToken) {
+  if (!refreshToken) throw new Error('缺少 refreshToken');
+  const form = new URLSearchParams();
+  form.set('grant_type', 'refresh_token');
+  form.set('refresh_token', refreshToken);
+  form.set('client_id', 'mcode-public');
+  form.set('scope', 'agent.default');
+  form.set('audience', 'agent-backend');
+
+  const res = await fetchJsonRace(TOKEN_REFRESH_URL, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/x-www-form-urlencoded',
+      Accept: 'application/json',
+    },
+    body: form.toString(),
+    timeoutMs: FETCH_TIMEOUT_MS,
+  });
+
+  if (!res.ok) {
+    const text = await res.text().catch(() => '');
+    const err = new Error(`MiniMax token 刷新失败: HTTP ${res.status} ${text}`);
+    if (res.status === 400 || res.status === 401) err.auth = true;
+    throw err;
+  }
+
+  const data = await res.json().catch(() => null);
+  if (!data?.access_token) throw new Error('MiniMax token 刷新未返回 access_token');
+
+  return {
+    accessToken: data.access_token,
+    refreshToken: data.refresh_token || refreshToken,
+    expiresIn: Number(data.expires_in) || 3600,
+  };
+}
+
+/**
+ * 带自动刷新 401 重试的高阶调用。
+ *
+ * 刷新前若该账号来自本机导入（meta.authRecordKey），先从 ~/.minimax auth.json 重读该 record 的
+ * 最新 refreshToken——本机客户端会独立轮换刷新，账号库快照可能已被服务端作废（invalid_grant）。
+ * 刷新成功后经 ctx.onRefresh 回写账号库，并尝试安全回写 auth.json（见 minimaxLocal.writeMiniMaxAuth）。
+ */
+export async function withMiniMaxAuth(account, fn, ctx = {}) {
+  try {
+    return await fn(account.token);
+  } catch (err) {
+    if (!err?.auth || !account.refreshToken) throw err;
+    const creds = await refreshAccountToken(account, ctx);
+    // 重试放在刷新之外：刷新成功但重试再 401 时，日志该说的是「重试仍被拒」，
+    // 而不是误导人的「自动刷新失败」（那时新 token 其实已经拿到并落库了）
+    return await fn(creds.token);
+  }
+}
+
+/**
+ * refreshToken 是一次性的、刷新即轮换：两个并发 401 拿同一个 refreshToken 去刷新，
+ * 必然一个成功一个 invalid_grant。签到轮（checkin）与面板的额度查询互不知情，
+ * 面板每 2 分钟刷一轮账号额度，很容易和 2 小时一次的签到轮撞上。
+ * 用 in-flight 表把同一账号的并发刷新合并成一次，后到者直接用刷新出来的新 token 重试。
+ */
+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
+    try {
+      const { alignMiniMaxFromLocal } = await import('./minimaxLocal.js');
+      alignMiniMaxFromLocal(account, ctx.log);
+    } catch {}
+    ctx.log?.('MiniMax token 已过期，正在自动刷新…');
+    try {
+      const refreshed = await refreshMiniMaxToken(account.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;
+      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;
+}
+
+/**
+ * 获取用户信息
+ */
+export async function fetchMiniMaxProfile(token) {
+  const res = await fetchJsonRace(PROFILE_URL, {
+    headers: authHeaders(token),
+    timeoutMs: FETCH_TIMEOUT_MS,
+  });
+  if (res.status === 401) {
+    const err = new Error('MiniMax 登录凭据已失效 (401)');
+    err.auth = true;
+    throw err;
+  }
+  if (!res.ok) throw new Error(`获取 MiniMax 用户信息失败: HTTP ${res.status}`);
+  const data = await res.json().catch(() => null);
+  if (!data || data.base_resp?.status_code !== 0) {
+    const msg = data?.base_resp?.status_msg || '未知错误';
+    throw new Error(`MiniMax 用户信息错误: ${msg}`);
+  }
+  return {
+    userId: String(data.user_id || ''),
+    name: data.user_name || null,
+    email: data.email || null,
+    avatarUrl: data.avatar_url || data.default_avatar_url || null,
+  };
+}
+
+/**
+ * 校验 MiniMax 账号 (verify)
+ */
+export async function verifyMiniMaxAccount(account) {
+  const p = await fetchMiniMaxProfile(account.token);
+  return {
+    name: p.name || `MiniMax_${p.userId.slice(-6)}`,
+    uid: p.userId,
+    email: p.email,
+  };
+}
+
+/**
+ * 查询额度 (quota)
+ */
+export async function fetchMiniMaxQuota(account, ctx = {}) {
+  return withMiniMaxAuth(account, async (token) => {
+    const res = await fetchJsonRace(MEMBERSHIP_URL, {
+      method: 'POST',
+      headers: {
+        ...authHeaders(token),
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({}),
+      timeoutMs: FETCH_TIMEOUT_MS,
+    });
+    if (res.status === 401) {
+      const err = new Error('MiniMax 凭据已失效 (401)');
+      err.auth = true;
+      throw err;
+    }
+    if (!res.ok) throw new Error(`获取 MiniMax 额度失败: HTTP ${res.status}`);
+    const data = await res.json().catch(() => null);
+    if (!data || data.base_resp?.status_code !== 0) {
+      const msg = data?.base_resp?.status_msg || '未知错误';
+      throw new Error(`MiniMax 额度错误: ${msg}`);
+    }
+    return normalizeMiniMaxQuota(data);
+  }, ctx);
+}
+
+/**
+ * 解析并归一化 MiniMax 额度
+ */
+export function normalizeMiniMaxQuota(data) {
+  const summary = data.op_credit_summary || {};
+  const total = Number(summary.total_remaining_amount ?? data.total_remains_credit) || 0;
+  const free = Number(summary.free_remaining_amount) || 0;
+  const purchased = Number(summary.purchased_remaining_amount) || 0;
+
+  const parts = [];
+  if (free > 0) {
+    parts.push({
+      name: '免费/活动积分',
+      total: free,
+      used: 0,
+      remaining: free,
+      recurring: true,
+      unit: '积分',
+    });
+  }
+  if (purchased > 0) {
+    parts.push({
+      name: '购买积分',
+      total: purchased,
+      used: 0,
+      remaining: purchased,
+      recurring: false,
+      unit: '积分',
+    });
+  }
+  if (!parts.length) {
+    parts.push({
+      name: '积分',
+      total,
+      used: 0,
+      remaining: total,
+      recurring: true,
+      unit: '积分',
+    });
+  }
+
+  return {
+    total: Math.round(total * 100) / 100,
+    used: 0,
+    remaining: Math.round(total * 100) / 100,
+    // 顶层不设 unit：面板 creditSum 用「有 unit 即异单位」来排除合计，
+    // MiniMax 与 Qoder / Trae 同为「积分」口径，必须计入剩余积分合计。
+    plan: data.plan_name || (data.is_pro_builder ? 'Pro' : '免费版'),
+    // expires_at 是毫秒时间戳：再乘 1000 会显示成 58729 年（实测免费版返回 0，按无到期处理）
+    planExpiresAt: isoMs(data.expires_at),
+    parts,
+    empty: total <= 0,
+  };
+}
+
+/**
+ * 每日自动签到 (checkin)
+ */
+export async function checkinMiniMax(account, ctx = {}) {
+  return withMiniMaxAuth(account, async (token) => {
+    // 1. 查询签到状态
+    const statusRes = await fetchJsonRace(SIGNIN_STATUS_URL, {
+      headers: authHeaders(token),
+      timeoutMs: FETCH_TIMEOUT_MS,
+    });
+    if (statusRes.status === 401) {
+      const err = new Error('MiniMax 凭据已失效 (401)');
+      err.auth = true;
+      throw err;
+    }
+    if (!statusRes.ok) throw new Error(`查询签到状态失败: HTTP ${statusRes.status}`);
+    const statusData = await statusRes.json().catch(() => null);
+    if (!statusData || statusData.base_resp?.status_code !== 0) {
+      throw new Error(`查询签到状态错误: ${statusData?.base_resp?.status_msg || '未知'}`);
+    }
+
+    const days = statusData.data?.days || [];
+    const today = days.find((d) => d.is_today);
+
+    // status: 3 = 已领取，1 = 未领取/待领取
+    if (today && today.status === 3) {
+      return {
+        status: 'already',
+        message: `今日第 ${today.day_no} 天已签到（${today.points} + ${today.bonus_points} 积分）`,
+        amount: (today.points || 0) + (today.bonus_points || 0),
+        streakDays: today.day_no || 0,
+      };
+    }
+
+    // 2. 发起签到 claim
+    const claimRes = await fetchJsonRace(SIGNIN_CLAIM_URL, {
+      method: 'POST',
+      headers: authHeaders(token),
+      timeoutMs: FETCH_TIMEOUT_MS,
+    });
+    if (claimRes.status === 401) {
+      const err = new Error('MiniMax 凭据已失效 (401)');
+      err.auth = true;
+      throw err;
+    }
+    if (!claimRes.ok) throw new Error(`签到领取失败: HTTP ${claimRes.status}`);
+    const claimData = await claimRes.json().catch(() => null);
+    if (!claimData || claimData.base_resp?.status_code !== 0) {
+      throw new Error(`签到领取错误: ${claimData?.base_resp?.status_msg || '未知'}`);
+    }
+
+    const cdata = claimData.data || {};
+    // claim_result: 1 = 新签到成功, 2 = 重复签到已领
+    const pts = Number(cdata.points) || (today ? (today.points || 0) + (today.bonus_points || 0) : 0);
+    if (cdata.claim_result === 2) {
+      return {
+        status: 'already',
+        message: `今日已领取（+${pts} 积分）`,
+        amount: pts,
+        streakDays: cdata.day_no || today?.day_no || 0,
+      };
+    }
+
+    return {
+      status: 'checked-in',
+      message: `签到成功第 ${cdata.day_no || today?.day_no || 1} 天（+${pts} 积分）`,
+      claimedAmount: pts,
+      amount: pts,
+      streakDays: cdata.day_no || today?.day_no || 0,
+    };
+  }, ctx);
+}