mslxdff 0.1.203 → 0.1.207

package/src/providers/raccoon/credits.js

@@ -1,185 +1,185 @@
-// raccoon 积分：余额五分项查询 + 登录奖励领取（幂等，判据只认账单）。
-// 这家是**积分制**，三种积分来源的性质（2026-10-10 账单流水实测 + 参考实现双向取证）：
-//   · 新人注册礼包 3000 —— 注册时服务端自动发，**无端点可领**
-//   · 每日积分发放 300 —— 每天服务端自动发，**当天 23:59:59 清零**（账单里有 `daily_expire`），也**无端点可领**
-//   · 桌面端登录奖励 3000 —— **每号一次性**，走 `POST /desktop/v1/login/points/grant`，唯一需要领的
-// ⚠ 上游对「已经领过」的重复请求**照样回 code:0**，但积分一分不到账 —— 所以 `code:0` 绝不能当成功凭据，
-//   必须用账单流水裁决（见 claimRaccoonLoginReward）。谎报成功会让 daemon/CLI 输出假到账，比报错更坏。
-import {
-  RACCOON_LOGIN_REWARD_EVENT_NAME,
-  RACCOON_LOGIN_REWARD_POINTS,
-  RACCOON_REQUEST_TIMEOUT_MS,
-  raccoonBalanceUrl,
-  raccoonBillsUrl,
-  raccoonLoginGrantUrl,
-} from "./const.js";
-import { raccoonAuthHeaders } from "./headers.js";
-import { confirmRaccoonSession } from "./login.js";
-import { parseRaccoonEnvelope, raccoonEnvelopeText } from "./envelope.js";
-
-const num = (v) => {
-  if (typeof v === "number" && Number.isFinite(v)) return v;
-  if (typeof v === "string" && /^-?\d+(\.\d+)?$/.test(v.trim())) return Number(v.trim());
-  return undefined;
-};
-
-/** 上游「新会话未确认」闸门码：先 POST /iam/confirm 再重试一次（与 chat.js 同款兜底）。 */
-const IAM_CONFIRM_REQUIRED = 200901;
-
-async function request(url, { credential, fetchImpl = fetch, env = process.env, method = "GET", body, timeoutMs = RACCOON_REQUEST_TIMEOUT_MS } = {}) {
-  const once = async () => {
-    const res = await fetchImpl(url, {
-      method,
-      headers: raccoonAuthHeaders(credential, { env }),
-      ...(body === undefined ? {} : { body: JSON.stringify(body) }),
-      signal: AbortSignal.timeout(timeoutMs),
-    });
-    let parsed;
-    try {
-      parsed = await res.json();
-    } catch {
-      throw new Error(`raccoon: 响应不是 JSON（HTTP ${res.status}）`);
-    }
-    return { res, envelope: parseRaccoonEnvelope(parsed, res.status) };
-  };
-  let { res, envelope } = await once();
-  // 未确认会话闸门：确认一次后重试（老号 / CLI 直连都可能撞上，登录时已确认的号不会走到这）
-  if (res.status === 400 && Number(envelope.code) === IAM_CONFIRM_REQUIRED) {
-    if (await confirmRaccoonSession(credential, { fetchImpl, env })) {
-      ({ res, envelope } = await once());
-    }
-  }
-  return envelope;
-}
-
-/** 余额五分项（缺项即省略，合计优先取上游的 available_points）。 */
-export function parseRaccoonBalance(data) {
-  const src = typeof data === "object" && data !== null ? data : {};
-  const available = num(src.available_points);
-  const reward = num(src.reward_points);
-  const daily = num(src.daily_points);
-  const topup = num(src.topup_points);
-  const monthly = num(src.monthly_points);
-  const items = [];
-  if (reward !== undefined) items.push({ key: "reward", label: "奖励积分", value: reward });
-  if (daily !== undefined) items.push({ key: "daily", label: "每日积分", value: daily });
-  if (monthly !== undefined) items.push({ key: "monthly", label: "月度积分", value: monthly });
-  if (topup !== undefined) items.push({ key: "topup", label: "充值积分", value: topup });
-  const total = available !== undefined ? available : items.reduce((s, i) => s + i.value, 0);
-  return { total, items };
-}
-
-export async function fetchRaccoonBalance(opts = {}) {
-  const envelope = await request(raccoonBalanceUrl(), opts);
-  if (envelope.code !== 0) {
-    const err = new Error(`raccoon: 查询积分失败：${raccoonEnvelopeText(envelope)}`);
-    err.code = envelope.code;
-    err.status = envelope.status;
-    throw err;
-  }
-  return parseRaccoonBalance(envelope.data);
-}
-
-/** 账单流水数组（上游把 list/items 两种形状都回过，容错取）。 */
-function billsRows(data) {
-  const list = Array.isArray(data?.list) ? data.list : Array.isArray(data?.items) ? data.items : Array.isArray(data) ? data : null;
-  return list === null ? undefined : list.filter((x) => typeof x === "object" && x !== null);
-}
-
-/** 上游的时间字段可能是秒/毫秒数字或 ISO 串，统一成毫秒。 */
-function billTimeMs(item) {
-  const at = item.created_at ?? item.createdAt ?? item.time;
-  if (typeof at === "number" && Number.isFinite(at)) return at > 1e12 ? at : at * 1000;
-  if (typeof at === "string") {
-    const ms = Date.parse(at);
-    if (Number.isFinite(ms)) return ms;
-  }
-  return undefined;
-}
-
-/**
- * 从账单里找「这个号历史上领过登录奖励没有」，返回 `{ points, at }` 或 undefined。
- * ⚠ 判据是**全历史**，不看日期窗口：登录奖励是每号一次性，用「今天」当窗口会让已领的号每天重新发请求，
- *   还会把"昨天领的"判成"没领过"。注册礼包同样是 `reward_grant`，所以 `event_name` 必须逐字比对。
- */
-export function findLoginRewardInBills(data) {
-  const rows = billsRows(data) || [];
-  for (const item of rows) {
-    if (item.biz_type !== "reward_grant") continue;
-    if (item.event_name !== RACCOON_LOGIN_REWARD_EVENT_NAME) continue;
-    const at = billTimeMs(item);
-    return { points: num(item.points) ?? RACCOON_LOGIN_REWARD_POINTS, ...(at === undefined ? {} : { at }) };
-  }
-  return undefined;
-}
-
-/** 拉一次账单流水；网络/解析任何失败都返回 undefined（判定降级，不抛）。 */
-async function readBills(opts) {
-  try {
-    const envelope = await request(raccoonBillsUrl(), opts);
-    return envelope?.code === 0 ? billsRows(envelope.data) : undefined;
-  } catch {
-    return undefined;
-  }
-}
-
-/**
- * 领取「桌面端登录奖励」（每号一次性）。返回三种非抛错结果之一：
- * - `{ claimed: true,  points }`  本次真到账（账单里出现了登录奖励那笔）
- * - `{ claimed: false, alreadyClaimed: true, points }`  历史已领（账单查到，或上游回 `granted:false`）
- * - `{ claimed: false, phantom: true,  points: 0 }`  上游回了 code:0 但账单没有这笔 —— 虚回，如实报未到账
- * - `{ claimed: false, unverified: true, points: 0 }`  账单查不动，无法确认到账（不猜、不谎报）
- * grant 请求本身失败（业务码非 0）且账单也查不到已领 → 抛错（如实透出）。
- */
-export async function claimRaccoonLoginReward({ credential, fetchImpl = fetch, env = process.env, timeoutMs } = {}) {
-  const opts = { credential, fetchImpl, env, timeoutMs };
-
-  const before = await readBills(opts);
-  const already = before === undefined ? undefined : findLoginRewardInBills(before);
-  if (already) return { claimed: false, alreadyClaimed: true, points: already.points };
-
-  let envelope;
-  try {
-    envelope = await request(raccoonLoginGrantUrl(), { ...opts, method: "POST", body: {} });
-  } catch (error) {
-    envelope = { code: -1, message: error?.message ?? String(error), status: 0, data: undefined };
-  }
-
-  // 上游用 `data.granted` 直接回答「这次到底发没发」—— 这是比账单更权威的判据，优先采信。
-  // `granted === false` ⇒ 本号此前已发过（一次性礼包），**不是「未到账」**。
-  // 为什么不能只靠账单：重度使用的号（如 daemon 正在跑的那个）账单会被「对话消耗」刷满，
-  //   分页窗口里根本翻不到那条陈年 reward_grant —— 此时只信账单就会把「早就领过」
-  //   误报成「上游回执成功但账单查不到 → 未到账」（实测踩到，教训）。
-  // 官方前端同款判据：granted 为真才弹「积分已到账」，为假就静默（见 app.asar grantDesktopLoginPoints 调用点）。
-  if (envelope?.code === 0 && envelope.data?.granted === false) {
-    return { claimed: false, alreadyClaimed: true, points: RACCOON_LOGIN_REWARD_POINTS };
-  }
-
-  // 未给 granted 判据（如上游老版本/测试桩）时回退账单复查 —— 到账凭据仍以账单为准。
-  const after = await readBills(opts);
-  const landed = after === undefined ? undefined : findLoginRewardInBills(after);
-  if (landed) {
-    const points = num(envelope?.data?.points) ?? num(envelope?.data?.popup?.points) ?? landed.points ?? RACCOON_LOGIN_REWARD_POINTS;
-    return { claimed: true, points };
-  }
-  if (after === undefined) return { claimed: false, unverified: true, points: 0 };
-  if (envelope?.code === 0) return { claimed: false, phantom: true, points: 0 };
-
-  const err = new Error(`raccoon: 领取登录积分失败：${raccoonEnvelopeText(envelope, "上游未返回原因")}`);
-  err.code = envelope.code;
-  err.status = envelope.status;
-  throw err;
-}
-
-/**
- * claimRaccoonLoginReward 的结果 → 统一状态字。daemon 与 CLI 共用，避免两处各写一份分支后漂移。
- * claimed=真到账 · already=一次性礼包此前已领过（正常态） · phantom=上游回执成功但账单没这笔 ·
- * unverified=账单查不动，不下结论 · error=真失败。
- */
-export function raccoonClaimStatus(r) {
-  if (r?.claimed) return "claimed";
-  if (r?.alreadyClaimed) return "already";
-  if (r?.phantom) return "phantom";
-  if (r?.unverified) return "unverified";
-  return "error";
-}
+// raccoon 积分：余额五分项查询 + 登录奖励领取（幂等，判据只认账单）。
+// 这家是**积分制**，三种积分来源的性质（2026-10-10 账单流水实测 + 参考实现双向取证）：
+//   · 新人注册礼包 3000 —— 注册时服务端自动发，**无端点可领**
+//   · 每日积分发放 300 —— 每天服务端自动发，**当天 23:59:59 清零**（账单里有 `daily_expire`），也**无端点可领**
+//   · 桌面端登录奖励 3000 —— **每号一次性**，走 `POST /desktop/v1/login/points/grant`，唯一需要领的
+// ⚠ 上游对「已经领过」的重复请求**照样回 code:0**，但积分一分不到账 —— 所以 `code:0` 绝不能当成功凭据，
+//   必须用账单流水裁决（见 claimRaccoonLoginReward）。谎报成功会让 daemon/CLI 输出假到账，比报错更坏。
+import {
+  RACCOON_LOGIN_REWARD_EVENT_NAME,
+  RACCOON_LOGIN_REWARD_POINTS,
+  RACCOON_REQUEST_TIMEOUT_MS,
+  raccoonBalanceUrl,
+  raccoonBillsUrl,
+  raccoonLoginGrantUrl,
+} from "./const.js";
+import { raccoonAuthHeaders } from "./headers.js";
+import { confirmRaccoonSession } from "./login.js";
+import { parseRaccoonEnvelope, raccoonEnvelopeText } from "./envelope.js";
+
+const num = (v) => {
+  if (typeof v === "number" && Number.isFinite(v)) return v;
+  if (typeof v === "string" && /^-?\d+(\.\d+)?$/.test(v.trim())) return Number(v.trim());
+  return undefined;
+};
+
+/** 上游「新会话未确认」闸门码：先 POST /iam/confirm 再重试一次（与 chat.js 同款兜底）。 */
+const IAM_CONFIRM_REQUIRED = 200901;
+
+async function request(url, { credential, fetchImpl = fetch, env = process.env, method = "GET", body, timeoutMs = RACCOON_REQUEST_TIMEOUT_MS } = {}) {
+  const once = async () => {
+    const res = await fetchImpl(url, {
+      method,
+      headers: raccoonAuthHeaders(credential, { env }),
+      ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+    let parsed;
+    try {
+      parsed = await res.json();
+    } catch {
+      throw new Error(`raccoon: 响应不是 JSON（HTTP ${res.status}）`);
+    }
+    return { res, envelope: parseRaccoonEnvelope(parsed, res.status) };
+  };
+  let { res, envelope } = await once();
+  // 未确认会话闸门：确认一次后重试（老号 / CLI 直连都可能撞上，登录时已确认的号不会走到这）
+  if (res.status === 400 && Number(envelope.code) === IAM_CONFIRM_REQUIRED) {
+    if (await confirmRaccoonSession(credential, { fetchImpl, env })) {
+      ({ res, envelope } = await once());
+    }
+  }
+  return envelope;
+}
+
+/** 余额五分项（缺项即省略，合计优先取上游的 available_points）。 */
+export function parseRaccoonBalance(data) {
+  const src = typeof data === "object" && data !== null ? data : {};
+  const available = num(src.available_points);
+  const reward = num(src.reward_points);
+  const daily = num(src.daily_points);
+  const topup = num(src.topup_points);
+  const monthly = num(src.monthly_points);
+  const items = [];
+  if (reward !== undefined) items.push({ key: "reward", label: "奖励积分", value: reward });
+  if (daily !== undefined) items.push({ key: "daily", label: "每日积分", value: daily });
+  if (monthly !== undefined) items.push({ key: "monthly", label: "月度积分", value: monthly });
+  if (topup !== undefined) items.push({ key: "topup", label: "充值积分", value: topup });
+  const total = available !== undefined ? available : items.reduce((s, i) => s + i.value, 0);
+  return { total, items };
+}
+
+export async function fetchRaccoonBalance(opts = {}) {
+  const envelope = await request(raccoonBalanceUrl(), opts);
+  if (envelope.code !== 0) {
+    const err = new Error(`raccoon: 查询积分失败：${raccoonEnvelopeText(envelope)}`);
+    err.code = envelope.code;
+    err.status = envelope.status;
+    throw err;
+  }
+  return parseRaccoonBalance(envelope.data);
+}
+
+/** 账单流水数组（上游把 list/items 两种形状都回过，容错取）。 */
+function billsRows(data) {
+  const list = Array.isArray(data?.list) ? data.list : Array.isArray(data?.items) ? data.items : Array.isArray(data) ? data : null;
+  return list === null ? undefined : list.filter((x) => typeof x === "object" && x !== null);
+}
+
+/** 上游的时间字段可能是秒/毫秒数字或 ISO 串，统一成毫秒。 */
+function billTimeMs(item) {
+  const at = item.created_at ?? item.createdAt ?? item.time;
+  if (typeof at === "number" && Number.isFinite(at)) return at > 1e12 ? at : at * 1000;
+  if (typeof at === "string") {
+    const ms = Date.parse(at);
+    if (Number.isFinite(ms)) return ms;
+  }
+  return undefined;
+}
+
+/**
+ * 从账单里找「这个号历史上领过登录奖励没有」，返回 `{ points, at }` 或 undefined。
+ * ⚠ 判据是**全历史**，不看日期窗口：登录奖励是每号一次性，用「今天」当窗口会让已领的号每天重新发请求，
+ *   还会把"昨天领的"判成"没领过"。注册礼包同样是 `reward_grant`，所以 `event_name` 必须逐字比对。
+ */
+export function findLoginRewardInBills(data) {
+  const rows = billsRows(data) || [];
+  for (const item of rows) {
+    if (item.biz_type !== "reward_grant") continue;
+    if (item.event_name !== RACCOON_LOGIN_REWARD_EVENT_NAME) continue;
+    const at = billTimeMs(item);
+    return { points: num(item.points) ?? RACCOON_LOGIN_REWARD_POINTS, ...(at === undefined ? {} : { at }) };
+  }
+  return undefined;
+}
+
+/** 拉一次账单流水；网络/解析任何失败都返回 undefined（判定降级，不抛）。 */
+async function readBills(opts) {
+  try {
+    const envelope = await request(raccoonBillsUrl(), opts);
+    return envelope?.code === 0 ? billsRows(envelope.data) : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * 领取「桌面端登录奖励」（每号一次性）。返回三种非抛错结果之一：
+ * - `{ claimed: true,  points }`  本次真到账（账单里出现了登录奖励那笔）
+ * - `{ claimed: false, alreadyClaimed: true, points }`  历史已领（账单查到，或上游回 `granted:false`）
+ * - `{ claimed: false, phantom: true,  points: 0 }`  上游回了 code:0 但账单没有这笔 —— 虚回，如实报未到账
+ * - `{ claimed: false, unverified: true, points: 0 }`  账单查不动，无法确认到账（不猜、不谎报）
+ * grant 请求本身失败（业务码非 0）且账单也查不到已领 → 抛错（如实透出）。
+ */
+export async function claimRaccoonLoginReward({ credential, fetchImpl = fetch, env = process.env, timeoutMs } = {}) {
+  const opts = { credential, fetchImpl, env, timeoutMs };
+
+  const before = await readBills(opts);
+  const already = before === undefined ? undefined : findLoginRewardInBills(before);
+  if (already) return { claimed: false, alreadyClaimed: true, points: already.points };
+
+  let envelope;
+  try {
+    envelope = await request(raccoonLoginGrantUrl(), { ...opts, method: "POST", body: {} });
+  } catch (error) {
+    envelope = { code: -1, message: error?.message ?? String(error), status: 0, data: undefined };
+  }
+
+  // 上游用 `data.granted` 直接回答「这次到底发没发」—— 这是比账单更权威的判据，优先采信。
+  // `granted === false` ⇒ 本号此前已发过（一次性礼包），**不是「未到账」**。
+  // 为什么不能只靠账单：重度使用的号（如 daemon 正在跑的那个）账单会被「对话消耗」刷满，
+  //   分页窗口里根本翻不到那条陈年 reward_grant —— 此时只信账单就会把「早就领过」
+  //   误报成「上游回执成功但账单查不到 → 未到账」（实测踩到，教训）。
+  // 官方前端同款判据：granted 为真才弹「积分已到账」，为假就静默（见 app.asar grantDesktopLoginPoints 调用点）。
+  if (envelope?.code === 0 && envelope.data?.granted === false) {
+    return { claimed: false, alreadyClaimed: true, points: RACCOON_LOGIN_REWARD_POINTS };
+  }
+
+  // 未给 granted 判据（如上游老版本/测试桩）时回退账单复查 —— 到账凭据仍以账单为准。
+  const after = await readBills(opts);
+  const landed = after === undefined ? undefined : findLoginRewardInBills(after);
+  if (landed) {
+    const points = num(envelope?.data?.points) ?? num(envelope?.data?.popup?.points) ?? landed.points ?? RACCOON_LOGIN_REWARD_POINTS;
+    return { claimed: true, points };
+  }
+  if (after === undefined) return { claimed: false, unverified: true, points: 0 };
+  if (envelope?.code === 0) return { claimed: false, phantom: true, points: 0 };
+
+  const err = new Error(`raccoon: 领取登录积分失败：${raccoonEnvelopeText(envelope, "上游未返回原因")}`);
+  err.code = envelope.code;
+  err.status = envelope.status;
+  throw err;
+}
+
+/**
+ * claimRaccoonLoginReward 的结果 → 统一状态字。daemon 与 CLI 共用，避免两处各写一份分支后漂移。
+ * claimed=真到账 · already=一次性礼包此前已领过（正常态） · phantom=上游回执成功但账单没这笔 ·
+ * unverified=账单查不动，不下结论 · error=真失败。
+ */
+export function raccoonClaimStatus(r) {
+  if (r?.claimed) return "claimed";
+  if (r?.alreadyClaimed) return "already";
+  if (r?.phantom) return "phantom";
+  if (r?.unverified) return "unverified";
+  return "error";
+}

package/src/providers/raccoon/crypto.js

@@ -1,43 +1,43 @@
-// raccoon 登录参数加密（手机号 / 密码）—— 单一源。
-//
-// 取证（2026-10-18：app.asar webpack module 68284 原文 + 本机真实账号实测）：
-//   官方登录页拿到输入后先调 `U.yv()` 再拼 body，而 `yv` 的真身就是这段：
-//     function c(e, t = "senseraccoon2023") {
-//       const a = CryptoJS.enc.Utf8.parse(t);
-//       const i = CryptoJS.lib.WordArray.random(16);                    // 随机 IV
-//       const r = CryptoJS.AES.encrypt(e, a, { iv: i, mode: CFB, padding: NoPadding });
-//       return i.concat(r.ciphertext).toString(CryptoJS.enc.Base64);
-//     }
-//   即 **key 与模式都硬编码在前端**：AES-128-CFB、key = "senseraccoon2023"、无 padding，
-//   输出 Base64(IV(16 字节) ‖ 密文)。手机号与密码走的是同一个函数 —— 两个字段都要加密。
-//
-// 为什么必须加密（否则极难自查）：明文发送时服务端解得空串再去比对，一律回
-// `AUTH_ACCOUNT_OR_PASSWORD_INVALID`（"手机号或密码不正确"）—— 用「密码错」的口径
-// 掩盖了「格式错」。本机用真实账号取证：明文 → 401；按本算法加密 → 200。
-// 且只加密手机号、密码留明文也是 401，可证**两个字段都加密**。
-//
-// ⚠ 这个 key 是**上游公开常量**（打包进任意客户端），不是本项目的机密；照抄它只为对齐协议，
-//   不代表传输具备保密性 —— 真正的保护来自 HTTPS，以及本项目「密码不落盘/不打印」的纪律。
-import { createCipheriv, randomBytes } from "node:crypto";
-import { RACCOON_PASSWORD_ENC_KEY } from "./const.js";
-
-const IV_BYTES = 16;
-
-/**
- * 加密单个登录字段（手机号或密码）→ Base64(IV ‖ AES-128-CFB 密文)。
- *
- * 与上游前端**逐位对齐**：同 key、同模式（CFB128，对齐 CryptoJS 的 `mode.CFB`）、
- * 同 padding（NoPadding —— CFB 是流模式，密文长度恒等于明文长度）、同拼接顺序。
- * 每次调用生成新的随机 IV（上游亦然）：同一输入两次调用密文不同，这是正确行为。
- */
-export function raccoonEncryptField(plain, keyStr = RACCOON_PASSWORD_ENC_KEY) {
-  const key = Buffer.from(String(keyStr ?? ""), "utf8");
-  if (key.length !== 16) throw new Error("raccoon: 登录加密 key 必须是 16 字节（AES-128）");
-  const iv = randomBytes(IV_BYTES);
-  const cipher = createCipheriv("aes-128-cfb", key, iv);
-  const body = Buffer.concat([
-    cipher.update(Buffer.from(String(plain ?? ""), "utf8")),
-    cipher.final(),
-  ]);
-  return Buffer.concat([iv, body]).toString("base64");
-}
+// raccoon 登录参数加密（手机号 / 密码）—— 单一源。
+//
+// 取证（2026-10-18：app.asar webpack module 68284 原文 + 本机真实账号实测）：
+//   官方登录页拿到输入后先调 `U.yv()` 再拼 body，而 `yv` 的真身就是这段：
+//     function c(e, t = "senseraccoon2023") {
+//       const a = CryptoJS.enc.Utf8.parse(t);
+//       const i = CryptoJS.lib.WordArray.random(16);                    // 随机 IV
+//       const r = CryptoJS.AES.encrypt(e, a, { iv: i, mode: CFB, padding: NoPadding });
+//       return i.concat(r.ciphertext).toString(CryptoJS.enc.Base64);
+//     }
+//   即 **key 与模式都硬编码在前端**：AES-128-CFB、key = "senseraccoon2023"、无 padding，
+//   输出 Base64(IV(16 字节) ‖ 密文)。手机号与密码走的是同一个函数 —— 两个字段都要加密。
+//
+// 为什么必须加密（否则极难自查）：明文发送时服务端解得空串再去比对，一律回
+// `AUTH_ACCOUNT_OR_PASSWORD_INVALID`（"手机号或密码不正确"）—— 用「密码错」的口径
+// 掩盖了「格式错」。本机用真实账号取证：明文 → 401；按本算法加密 → 200。
+// 且只加密手机号、密码留明文也是 401，可证**两个字段都加密**。
+//
+// ⚠ 这个 key 是**上游公开常量**（打包进任意客户端），不是本项目的机密；照抄它只为对齐协议，
+//   不代表传输具备保密性 —— 真正的保护来自 HTTPS，以及本项目「密码不落盘/不打印」的纪律。
+import { createCipheriv, randomBytes } from "node:crypto";
+import { RACCOON_PASSWORD_ENC_KEY } from "./const.js";
+
+const IV_BYTES = 16;
+
+/**
+ * 加密单个登录字段（手机号或密码）→ Base64(IV ‖ AES-128-CFB 密文)。
+ *
+ * 与上游前端**逐位对齐**：同 key、同模式（CFB128，对齐 CryptoJS 的 `mode.CFB`）、
+ * 同 padding（NoPadding —— CFB 是流模式，密文长度恒等于明文长度）、同拼接顺序。
+ * 每次调用生成新的随机 IV（上游亦然）：同一输入两次调用密文不同，这是正确行为。
+ */
+export function raccoonEncryptField(plain, keyStr = RACCOON_PASSWORD_ENC_KEY) {
+  const key = Buffer.from(String(keyStr ?? ""), "utf8");
+  if (key.length !== 16) throw new Error("raccoon: 登录加密 key 必须是 16 字节（AES-128）");
+  const iv = randomBytes(IV_BYTES);
+  const cipher = createCipheriv("aes-128-cfb", key, iv);
+  const body = Buffer.concat([
+    cipher.update(Buffer.from(String(plain ?? ""), "utf8")),
+    cipher.final(),
+  ]);
+  return Buffer.concat([iv, body]).toString("base64");
+}

package/src/providers/raccoon/envelope.js

@@ -1,31 +1,31 @@
-// raccoon 上游统一信封：`{ code, message, details, data }`（与 pack.js 的 parseEnvelope 同形）。
-// ⚠ 两代通道的成功码不同（2026-10 上游改版）：旧 /api/web/* 用数字 `0`，新 /api/iam/v1/* 用字符串 `"OK"`。
-//   故 `code` 原样保留（数字或字符串），判成功一律走 isRaccoonOk()——**不能**再用 `code === 0`：
-//   字符串码一律不等于 0（把 "OK" 判成失败），而把它兜底成 0 又会把 `AUTH_QRCODE_EXPIRED` 判成成功。
-// 登录态类业务码：200001 未带 token、200003 登录态过期 —— 见 const.js 的 RACCOON_ERROR_KINDS。
-export function parseRaccoonEnvelope(payload, status = 200) {
-  const record = typeof payload === "object" && payload !== null && !Array.isArray(payload) ? payload : {};
-  const raw = record.code;
-  const code = typeof raw === "number" || typeof raw === "string" ? raw : status >= 400 ? status : 0;
-  const message = typeof record.message === "string" ? record.message : "";
-  const details = typeof record.details === "string" ? record.details : "";
-  const data = typeof record.data === "object" && record.data !== null && !Array.isArray(record.data) ? record.data : undefined;
-  return { code, message, details, data, status };
-}
-
-/** 业务成功判据（两代通道通用）：数字 0，或新 IAM 通道的字符串 "OK"。 */
-export function isRaccoonOk(envelope) {
-  return envelope?.code === 0 || envelope?.code === "OK";
-}
-
-/** 人话错误文本：`message: details`，都没有时用调用方给的兜底句。 */
-export function raccoonEnvelopeText(envelope, fallback = "请求失败") {
-  const parts = [envelope?.message, envelope?.details].filter((s) => typeof s === "string" && s.length > 0);
-  return parts.length > 0 ? parts.join("：") : fallback;
-}
-
-/** 登录态失效判据：HTTP 401 或业务码 200001/200003。 */
-export function isRaccoonAuthFailure(envelope, status) {
-  if (status === 401) return true;
-  return envelope?.code === 200001 || envelope?.code === 200003;
-}
+// raccoon 上游统一信封：`{ code, message, details, data }`（与 pack.js 的 parseEnvelope 同形）。
+// ⚠ 两代通道的成功码不同（2026-10 上游改版）：旧 /api/web/* 用数字 `0`，新 /api/iam/v1/* 用字符串 `"OK"`。
+//   故 `code` 原样保留（数字或字符串），判成功一律走 isRaccoonOk()——**不能**再用 `code === 0`：
+//   字符串码一律不等于 0（把 "OK" 判成失败），而把它兜底成 0 又会把 `AUTH_QRCODE_EXPIRED` 判成成功。
+// 登录态类业务码：200001 未带 token、200003 登录态过期 —— 见 const.js 的 RACCOON_ERROR_KINDS。
+export function parseRaccoonEnvelope(payload, status = 200) {
+  const record = typeof payload === "object" && payload !== null && !Array.isArray(payload) ? payload : {};
+  const raw = record.code;
+  const code = typeof raw === "number" || typeof raw === "string" ? raw : status >= 400 ? status : 0;
+  const message = typeof record.message === "string" ? record.message : "";
+  const details = typeof record.details === "string" ? record.details : "";
+  const data = typeof record.data === "object" && record.data !== null && !Array.isArray(record.data) ? record.data : undefined;
+  return { code, message, details, data, status };
+}
+
+/** 业务成功判据（两代通道通用）：数字 0，或新 IAM 通道的字符串 "OK"。 */
+export function isRaccoonOk(envelope) {
+  return envelope?.code === 0 || envelope?.code === "OK";
+}
+
+/** 人话错误文本：`message: details`，都没有时用调用方给的兜底句。 */
+export function raccoonEnvelopeText(envelope, fallback = "请求失败") {
+  const parts = [envelope?.message, envelope?.details].filter((s) => typeof s === "string" && s.length > 0);
+  return parts.length > 0 ? parts.join("：") : fallback;
+}
+
+/** 登录态失效判据：HTTP 401 或业务码 200001/200003。 */
+export function isRaccoonAuthFailure(envelope, status) {
+  if (status === 401) return true;
+  return envelope?.code === 200001 || envelope?.code === 200003;
+}

package/src/providers/raccoon/headers.js

@@ -1,45 +1,45 @@
-// raccoon 出站请求头：与官方客户端同形（逐字段对齐 pack.js 的 raccoonHeaders）。
-// 风控按版本/头判断，形态错会 401/403 —— 所以这里不做「优化」，只做照抄。
-import {
-  RACCOON_CLIENT_LANGUAGE,
-  RACCOON_CLIENT_PLATFORM,
-  raccoonClientVersion,
-  raccoonUserAgent,
-} from "./const.js";
-
-/** 匿名头：登录轮询等不需要 token 的调用（官方客户端在这些路径也不带 Authorization）。 */
-export function raccoonAnonymousHeaders({ env = process.env, accept = "application/json" } = {}) {
-  return {
-    Accept: accept,
-    "Content-Type": "application/json",
-    "User-Agent": raccoonUserAgent(env),
-    "X-Raccoon-Language": RACCOON_CLIENT_LANGUAGE,
-    "X-Client-Platform": RACCOON_CLIENT_PLATFORM,
-    "X-Client-Version": raccoonClientVersion(env),
-  };
-}
-
-/**
- * 带 token 的出站头。
- * - `X-Org-Code`：个人号为空串（官方客户端总是发送该头）。
- * - `X-Client-Device-ID`：**为空则不发**（个人号可选；被网关拒时的退化路径）。
- * - `X-Client-Version` / `User-Agent` 走 env 可配（见 const.js）。
- */
-export function raccoonAuthHeaders(credential, { env = process.env, accept = "application/json", version } = {}) {
-  const headers = {
-    Accept: accept,
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${String(credential?.access_token ?? "")}`,
-    "X-Org-Code": String(credential?.office_identity ?? ""),
-    "X-Raccoon-Language": RACCOON_CLIENT_LANGUAGE,
-    "X-Client-Platform": RACCOON_CLIENT_PLATFORM,
-    "X-Client-Version": version || raccoonClientVersion(env),
-    "User-Agent": raccoonUserAgent(env),
-  };
-  const deviceId = String(credential?.device_id ?? "").trim();
-  if (deviceId) headers["X-Client-Device-ID"] = deviceId;
-  return headers;
-}
-
-/** 聊天的 Accept 要比 JSON 宽：上游流式与非流式共用同一端点。 */
-export const RACCOON_CHAT_ACCEPT = "text/event-stream, application/json";
+// raccoon 出站请求头：与官方客户端同形（逐字段对齐 pack.js 的 raccoonHeaders）。
+// 风控按版本/头判断，形态错会 401/403 —— 所以这里不做「优化」，只做照抄。
+import {
+  RACCOON_CLIENT_LANGUAGE,
+  RACCOON_CLIENT_PLATFORM,
+  raccoonClientVersion,
+  raccoonUserAgent,
+} from "./const.js";
+
+/** 匿名头：登录轮询等不需要 token 的调用（官方客户端在这些路径也不带 Authorization）。 */
+export function raccoonAnonymousHeaders({ env = process.env, accept = "application/json" } = {}) {
+  return {
+    Accept: accept,
+    "Content-Type": "application/json",
+    "User-Agent": raccoonUserAgent(env),
+    "X-Raccoon-Language": RACCOON_CLIENT_LANGUAGE,
+    "X-Client-Platform": RACCOON_CLIENT_PLATFORM,
+    "X-Client-Version": raccoonClientVersion(env),
+  };
+}
+
+/**
+ * 带 token 的出站头。
+ * - `X-Org-Code`：个人号为空串（官方客户端总是发送该头）。
+ * - `X-Client-Device-ID`：**为空则不发**（个人号可选；被网关拒时的退化路径）。
+ * - `X-Client-Version` / `User-Agent` 走 env 可配（见 const.js）。
+ */
+export function raccoonAuthHeaders(credential, { env = process.env, accept = "application/json", version } = {}) {
+  const headers = {
+    Accept: accept,
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${String(credential?.access_token ?? "")}`,
+    "X-Org-Code": String(credential?.office_identity ?? ""),
+    "X-Raccoon-Language": RACCOON_CLIENT_LANGUAGE,
+    "X-Client-Platform": RACCOON_CLIENT_PLATFORM,
+    "X-Client-Version": version || raccoonClientVersion(env),
+    "User-Agent": raccoonUserAgent(env),
+  };
+  const deviceId = String(credential?.device_id ?? "").trim();
+  if (deviceId) headers["X-Client-Device-ID"] = deviceId;
+  return headers;
+}
+
+/** 聊天的 Accept 要比 JSON 宽：上游流式与非流式共用同一端点。 */
+export const RACCOON_CHAT_ACCEPT = "text/event-stream, application/json";