magicrew-auth 0.3.16 → 0.3.23

package/src/captcha.mjs

@@ -0,0 +1,275 @@
+// 无头登录的底层：旋转验证码 + 手机验证码换取登录态
+//
+// 全部是**纯 HTTP**，不开浏览器、不读 localStorage。协议是从网页版
+// `SMSVerificationCodeForm` chunk 里逆出来的，每一步都实测过
+// （见 docs/internals.md「无头登录」一节）：
+//
+//   ① POST /captcha/generate   { account_type, mobile, state_code }
+//        → { token, image(data:image/webp;base64,…), expire_time }
+//   ② 算角度 → angle = enc(deg, n)
+//   ③ POST /captcha/verify     { token, angle, account_type, mobile, state_code }
+//        → { verified: true, business_token: "biz_…" }
+//   ④ POST /v4/user/send-sms   { type, phone, state_code }
+//        + header `X-Captcha-Token: <business_token>`
+//   ⑤ POST /v4/user/login      { type: "phone_captcha", phone, state_code, code, device }
+//
+// ⚠ 三个域名各管一段，别混：
+//     www.<站点>            → 前端页面（只用来取 Origin，别的没用）
+//     i-keewood-service…    → captcha / v4 用户中心（①②③④⑤ 全在这）
+//     模型网关              → 与登录无关
+//
+// ⚠ 风控是真的（实测）：
+//      · 「验证次数已超限」  同一 token 试错有上限
+//      · 「验证不存在或已过期」 expire_time 给 10 分钟
+//      · 「验证提交过于频繁」  连续批量提交会被拦
+//   ⇒ 不能枚举角度，一次要算准；失败就换图重来。
+
+/** 服务端只认这一套 Unicode；错误码直接用数字，日志里好 grep */
+export const CAPTCHA_CODE = {
+  OK: 1000,
+  BAD: 2000,
+}
+
+/**
+ * 用户中心的域名按站点分，**两站的命名规则还不一样**（别照抄前缀）：
+ *
+ *   国内 www.letsmagic.cn → https://i-keewood-service.teamshare.cn   ← 有 `i-`，根域是 teamshare.cn
+ *   国际 www.magicrew.ai  → https://keewood-service.magicrew.ai      ← 没有 `i-`
+ *
+ * 出处：桌面客户端内嵌配置里的 `MAGIC_SERVICE_KEEWOOD_BASE_URL`
+ *       （`GET https://www.magicrew.ai/workspace` 的 HTML 里能直接读到）。
+ * 两个都实测过 `POST /captcha/generate` 回 200。
+ */
+export function keewoodOf(site) {
+  return site.id === "magicrew" ? "https://i-keewood-service.teamshare.cn" : "https://keewood-service.magicrew.ai"
+}
+
+/**
+ * 拖动角度 → 服务端要的 angle 字符串。
+ *
+ * 前端是这么算的（`SMSVerificationCodeForm` chunk，混淆过但结构清楚）：
+ *
+ *   Se(deg, n) = ((52249517 * (deg + n) + 5976906165) & 0xFFFFFFFF)
+ *   angle      = String(Se(deg, n)) + String(n)     // n = Date.now() % 90000 + 10000
+ *
+ * 验证方式：抓浏览器真实提交的 4 组 angle，对每组正向穷举 deg 0…359，
+ * **每组都唯一命中**，且命中值与拖动像素严格成 1.6°/px（225px = 360°）。
+ * 所以这里照抄，别改系数。
+ *
+ * ⚠ deg 是「图片顺时针旋转的角度」，0…359。不是「还差多少度」。
+ */
+export function encodeAngle(deg, n) {
+  const d = ((BigInt(deg) % 360n) + 360n) % 360n
+  const nn = BigInt(n)
+  const v = (52249517n * (d + nn) + 5976906165n) & 0xffffffffn
+  return String(v) + String(n)
+}
+
+/** 服务端给的 n 是 5 位（10000…99999）；我们自己造一个同样形状的 */
+export function randomN() {
+  return Math.floor(Math.random() * 90000) + 10000
+}
+
+/**
+ * 钟点 → deg。
+ *
+ * 判官回答的是「主体自己的上方向指向钟面的几点」（12=正上、3=正右）。
+ * 图要**顺时针**转多少度才立起来 = (12 - clock) * 30。
+ */
+export function clockToDeg(clock) {
+  const x = Number(clock)
+  if (!Number.isFinite(x)) return null
+  return Math.round((((12 - x) * 30) % 360 + 360) % 360)
+}
+
+/** 两个判官分歧多大（按钟点，取最短环距 0…6） */
+export function clockSpread(a, b) {
+  if (!Number.isFinite(a) || !Number.isFinite(b)) return 6
+  const d = Math.abs(((a - b) % 12 + 12) % 12)
+  return Math.min(d, 12 - d)
+}
+
+/** 分歧超过这个值就认为「有人把方向看反了」，宁可重来也不要瞎提交 */
+export const CLOCK_MAX_SPREAD = 1.5
+
+async function postJSON(url, body, { headers = {}, timeoutMs = 20_000 } = {}) {
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "content-type": "application/json", ...headers },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(timeoutMs),
+  })
+  const text = await res.text()
+  let json = null
+  try {
+    json = JSON.parse(text)
+  } catch {
+    /* 非 JSON 就当文本报出去 */
+  }
+  return { status: res.status, text, json }
+}
+
+/** ① 取图。返回 null 表示服务端认为这个号**已经注册**，直接给了 business_token（跳过验证） */
+export async function generateCaptcha(site, { mobile, stateCode = "+86" } = {}) {
+  const host = keewoodOf(site)
+  const { json } = await postJSON(`${host}/captcha/generate`, {
+    account_type: "mobile",
+    mobile,
+    state_code: stateCode,
+  }, { headers: { origin: site.web } })
+
+  const data = json?.data ?? {}
+  if (data.business_token) return { registered: true, businessToken: data.business_token }
+  if (!data.token || !data.image) {
+    throw new Error(`取验证码失败：${json?.message ?? "没有 token/image"}`)
+  }
+  return {
+    registered: false,
+    token: data.token,
+    image: String(data.image),
+    expireAt: data.expire_time ? Number(data.expire_time) * 1000 : null,
+  }
+}
+
+/** ③ 提交角度 */
+export async function verifyCaptcha(site, { token, deg, mobile, stateCode = "+86" }) {
+  const host = keewoodOf(site)
+  const n = randomN()
+  const { json } = await postJSON(`${host}/captcha/verify`, {
+    account_type: "mobile",
+    token,
+    angle: encodeAngle(deg, n),
+    mobile,
+    state_code: stateCode,
+  }, { headers: { origin: site.web } })
+
+  const data = json?.data ?? {}
+  if (data.verified && data.business_token) return { ok: true, businessToken: data.business_token }
+  return { ok: false, message: json?.message ?? "验证失败" }
+}
+
+/**
+ * ④ 发短信。businessToken 缺了/假的都会被打回来，所以它必须是真的。
+ *
+ * ⚠ `type` 是 **`"account_login"`**，不是 `"login"`、也不是登录枚举里的 `phone_captcha`。
+ *   填错的表现是「服务异常，请联系管理员」(9999) —— 后端内部炸了，不是参数校验失败，
+ *   所以从错误信息上完全看不出是 type 的问题。这个值是从浏览器真实请求里抓到的：
+ *     {"type":"account_login","phone":"199…","state_code":"+86"}
+ *   ⇒ 别再按直觉改它。
+ */
+export async function sendSms(site, { phone, stateCode = "+86", businessToken, type = "account_login" }) {
+  const host = keewoodOf(site)
+  const { json } = await postJSON(`${host}/v4/user/send-sms`, {
+    type,
+    phone,
+    state_code: stateCode,
+  }, { headers: { origin: site.web, "X-Captcha-Token": businessToken || "" } })
+
+  if (json?.code === CAPTCHA_CODE.OK) return { ok: true }
+  return { ok: false, message: json?.message ?? "发送短信失败" }
+}
+
+/**
+ * ⑤ 验证码换登录态。
+ *
+ * ⚠ `device` 是必须的，而且结构是一层层试出来的：
+ *     缺 device        → 「系统异常」(9999)
+ *     device 不是对象   → 「系统异常」
+ *     { device_id }    → 「id 字段是必须的」
+ *     { id, name }     → 放行，返回 2168「验证码错误」
+ *   ⇒ { id: 64 位 hex, name: "web" } 就够。
+ *
+ * ⚠ `auto_register` / `redirect` 一个都不能省（这是网页表单的初始值，抠出来的）：
+ *
+ *     { phone, state_code, code, auto_register: true,
+ *       type: "phone_captcha", redirect: window.location.href }
+ *
+ *   · `auto_register: true` —— 否则新号登不进来（只会报账号不存在）
+ *   · `redirect` 是**当前页面的 URL**，服务端从它上面取 `?invitation=<码>`。
+ *     ⇒ **邀请码是靠 redirect 传的，不是独立字段**。这就是为什么浏览器登录的
+ *       URL 必须带 `?invitation=`：不带，新注册的号就没有邀请关系。
+ */
+export async function loginBySmsCode(
+  site,
+  { phone, stateCode = "+86", code, device, autoRegister = true, redirect },
+) {
+  const host = keewoodOf(site)
+  const body = {
+    type: "phone_captcha",
+    phone,
+    state_code: stateCode,
+    code,
+    auto_register: autoRegister,
+    device: device ?? { id: makeDeviceId(), name: "web" },
+  }
+  if (redirect) body.redirect = redirect
+
+  const { json, status, text } = await postJSON(`${host}/v4/user/login`, body, {
+    headers: { origin: site.web },
+  })
+
+  return { json, status, text }
+}
+
+/** 64 位 hex，形状与网页版 cus.device_id 一致 */
+export function makeDeviceId() {
+  const bytes = new Uint8Array(32)
+  crypto.getRandomValues(bytes)
+  return [...bytes].map((b) => b.toString(16).padStart(2, "0")).join("")
+}
+
+/**
+ * 从登录响应里把 jwt / 组织码抠出来。
+ *
+ * ⚠ 这两个字段的真实形状**没实测过**（手上没有能收短信的号，只能验到 2168）。
+ *   所以这里做成「穷举常见键名 + 顺着对象往下找」的两层兜底，
+ *   并且把原始响应留在返回值里，出问题时日志能直接看到该怎么改。
+ */
+export function extractCreds(payload) {
+  const seen = new Set()
+  let jwt = null
+  let org = null
+
+  const looksJwt = (v) => typeof v === "string" && v.startsWith("eyJ") && v.split(".").length === 3
+  const looksOrg = (v) => typeof v === "string" && /^[a-z0-9]{6,32}$/i.test(v) && !looksJwt(v)
+
+  // 这些键名是服务端真实用的（实测 `login-data` 的形状），优先级高于「键名里带 org」的泛匹配 ——
+  // 后者会撞上 `organization_name: ""`、`organization_logo: null` 这类同名前缀的字段。
+  const STRONG_ORG_KEYS = [
+    "magic_organization_code",
+    "third_platform_organization_code",
+    "teamshare_organization_code",
+    "organization_code",
+    "organizationCode",
+  ]
+
+  const walk = (node, depth) => {
+    if (!node || depth > 5 || seen.has(node)) return
+    if (typeof node !== "object") return
+    seen.add(node)
+
+    for (const [k, v] of Object.entries(node)) {
+      if (!jwt && looksJwt(v)) jwt = v
+      if (!org && STRONG_ORG_KEYS.includes(k) && looksOrg(v)) org = v
+    }
+    // 弱匹配兜底：键名带 org 且值形似组织码
+    if (!org) {
+      for (const [k, v] of Object.entries(node)) {
+        if (looksOrg(v) && /org/i.test(k)) {
+          org = v
+          break
+        }
+      }
+    }
+    for (const v of Object.values(node)) {
+      if (v && typeof v === "object") {
+        if (Array.isArray(v)) {
+          for (const item of v.slice(0, 5)) walk(item, depth + 1)
+        } else walk(v, depth + 1)
+      }
+    }
+  }
+  walk(payload, 0)
+
+  return { jwt, org }
+}

package/src/headless.mjs

@@ -0,0 +1,287 @@
+// 无头登录的编排：一条纯 HTTP 的链路，不开浏览器
+//
+//   取图 → 识图判角度 → 过验证 → 发短信 → （用户填码）→ 换登录态 → 拿组织码
+//
+// 每一步都实测过（见 docs/internals.md「无头登录」）：
+//   · 取图/过验证在 keewood 用户中心，纯 JSON，不需要 cookie 或指纹
+//   · 角度必须「一次算准」：同一 token 试错次数有限，且高频会被拦
+//   · 识图模型是用户在 magpie 里选的那个（settings.json 的 vision）
+//
+// ⚠ 没有识图模型时**不在这里瞎猜** —— 猜中的概率只有 ~5.6%（容差 ±10°），
+//   平均要试十几次，先撞上的会是「验证提交过于频繁」。那种情况走浏览器回退
+//   （见 hooks/methods.mjs 的 another method），让用户自己转那一下。
+
+import {
+  extractCreds,
+  generateCaptcha,
+  loginBySmsCode,
+  sendSms,
+  verifyCaptcha,
+} from "./captcha.mjs"
+import { decideDegFromImage, readVisionModel } from "./vision.mjs"
+
+/** 一次登录最多换几张图；每张图只提交一次（风控不允许反复试同一个 token） */
+const MAX_CAPTCHA_ROUNDS = 4
+/** 两次提交之间歇一下，避开「验证提交过于频繁」 */
+const ROUND_GAP_MS = 2500
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
+
+/**
+ * 过掉旋转验证，拿到 business_token。
+ *
+ * @returns {Promise<{businessToken:string, rounds:number, log:string[]}>}
+ */
+export async function passCaptcha(site, { mobile, stateCode = "+86" } = {}) {
+  const log = []
+  let lastReason = ""
+
+  for (let round = 1; round <= MAX_CAPTCHA_ROUNDS; round++) {
+    const cap = await generateCaptcha(site, { mobile, stateCode })
+    // 已注册的号，服务端直接给 business_token，连图都不用看
+    if (cap.registered) {
+      log.push(`第 ${round} 轮：服务端直接放行（该号已注册）`)
+      return { businessToken: cap.businessToken, rounds: round, log }
+    }
+
+    const decided = await decideDegFromImage(cap.image)
+    if (!decided.ok) {
+      // 判不出来 / 两个判官对着干 → 换一张图，不要浪费一次提交
+      lastReason = `${decided.reason}${decided.detail ? `：${decided.detail}` : ""}`
+      log.push(`第 ${round} 轮：判角度不可信（${lastReason}），换图`)
+      if (round < MAX_CAPTCHA_ROUNDS) await sleep(500)
+      continue
+    }
+
+    const res = await verifyCaptcha(site, { token: cap.token, deg: decided.deg, mobile, stateCode })
+    if (res.ok) {
+      log.push(`第 ${round} 轮：deg=${decided.deg}（钟点 ${decided.clock?.toFixed?.(2) ?? "?"}，分歧 ${decided.spread?.toFixed?.(1) ?? 0}）→ 通过`)
+      return { businessToken: res.businessToken, rounds: round, log }
+    }
+
+    lastReason = res.message
+    log.push(`第 ${round} 轮：deg=${decided.deg} 没通过（${res.message}）`)
+    if (round < MAX_CAPTCHA_ROUNDS) await sleep(ROUND_GAP_MS)
+  }
+
+  throw Object.assign(
+    new Error(`旋转验证连试 ${MAX_CAPTCHA_ROUNDS} 张图都没过（最后一次：${lastReason}）`),
+    { captchaLog: log },
+  )
+}
+
+/**
+ * 第 1 步：发短信。成功即代表「验证已经过了」——服务端把 business_token 当门票。
+ */
+export async function startSmsLogin(site, { mobile, stateCode = "+86" } = {}) {
+  if (!readVisionModel()) {
+    // 调用方应该先判断这个；走到这里说明判断被绕过了 —— 明确报出来，别静默瞎猜
+    throw Object.assign(new Error("没有配置识图模型，不能无头过旋转验证"), { code: "no-vision-model" })
+  }
+
+  const { businessToken, rounds, log } = await passCaptcha(site, { mobile, stateCode })
+  const sms = await sendSms(site, { phone: mobile, stateCode, businessToken })
+  if (!sms.ok) {
+    throw Object.assign(new Error(`发短信失败：${sms.message}`), { captchaLog: log })
+  }
+  return { businessToken, rounds, log }
+}
+
+/**
+ * 第 2 步：验证码换登录态，并补齐组织码。
+ *
+ * ⚠ 登录响应里 jwt / 组织码的**确切形状没实测过**（手上没有能收短信的号，
+ *   只能验到 2168「验证码错误」）。所以：
+ *     · jwt 用 extractCreds 从响应里按特征找（以 eyJ 开头的三段式）
+ *     · 组织码找不着就调 `/api/v1/aggregation/login-data`（带 authorization 头，
+ *       服务端会回这个账号所在的组织列表）—— 这条路径是文档里查得到的
+ */
+export async function finishSmsLogin(site, { mobile, stateCode = "+86", code, device, redirect }) {
+  const { json, status, text } = await loginBySmsCode(site, {
+    phone: mobile,
+    stateCode,
+    code,
+    device,
+    autoRegister: true,
+    redirect,
+  })
+  if (!json) {
+    throw new Error(`登录接口回了非 JSON（HTTP ${status}）：${String(text).slice(0, 200)}`)
+  }
+  if (json.code !== 1000) {
+    // 2168 是验证码错；其余原样透出，别把它吞成「登录失败」
+    throw Object.assign(new Error(`登录失败：${json.message ?? json.code}`), {
+      code: json.code,
+      raw: json,
+    })
+  }
+
+  const { jwt, org } = extractLoginCreds(json)
+  if (!jwt) {
+    throw Object.assign(
+      new Error(`登录成功但响应里没找到可用令牌。响应结构：${describeShape(json)}`),
+      { raw: json },
+    )
+  }
+  // 响应里给了组织码就用它；没给就把该账号的组织**全列出来**，
+  // 由调用方逐个拿 fetchPoints 验（见 methods.mjs 的 completeSignIn）。
+  const orgs = org ? [org] : await fetchOrgs(site, jwt)
+  if (!orgs.length) {
+    throw Object.assign(
+      new Error(
+        `登录成功但拿不到组织码。\n` +
+          `  · 登录响应结构：${describeShape(json)}\n` +
+          `  · 用该令牌调 login-data 的探测结果：${orgProbeErrors().join(" / ") || "（没探）"}\n` +
+          `  （前端拿 access_token 直接 setAuthorization 后就用它调这个接口）`,
+      ),
+      { raw: json },
+    )
+  }
+  return { jwt, org: orgs[0], orgs, raw: json }
+}
+
+/**
+ * 把一段 JSON 的形状描述出来：**只有键名和类型，没有任何值**。
+ *
+ * 用来让真机上的报错自带诊断信息 —— 用户截一张图，就能看出服务端到底回了什么结构，
+ * 不用反复试。token 之类的东西一律不会出现在这里。
+ */
+export function describeShape(o, depth = 0) {
+  if (o === null) return "null"
+  if (o === undefined) return "undefined"
+  const t = typeof o
+  if (t !== "object") return t === "string" ? `str(${String(o).length})` : t
+  if (depth >= 3) return "…"
+  if (Array.isArray(o)) {
+    return `[${o.length}]` + (o.length ? describeShape(o[0], depth + 1) : "")
+  }
+  const keys = Object.keys(o).slice(0, 24)
+  return "{" + keys.map((k) => `${k}:${describeShape(o[k], depth + 1)}`).join(", ") + "}"
+}
+
+/**
+ * 从登录响应里取「授权令牌」和「组织码」。
+ *
+ * ⚠ 登录返回的**不是 JWT，是 `access_token`** —— 前端拿到之后立刻
+ *   `setAuthorization(access_token)` 并用它调 `getUserProfile`。
+ *   早先这里只按 `eyJ` 前缀找 JWT，结果在响应里挑到了别的字段，
+ *   拿去调 `login-data` 自然拿不到组织（真机表现就是
+ *   「登录成功但拿不到组织码」）。
+ */
+function extractLoginCreds(json) {
+  const d = json?.data ?? json ?? {}
+  const pick = (...keys) => {
+    for (const k of keys) {
+      const v = d?.[k]
+      if (typeof v === "string" && v.trim()) return v.trim()
+    }
+    return null
+  }
+  // 优先认登录接口自己给的字段名
+  const token =
+    pick("access_token", "accessToken", "token", "authorization", "teamshare_token") ??
+    extractCreds(json).jwt
+  const org =
+    pick("organization_code", "organizationCode", "magic_organization_code") ??
+    extractCreds(json).org
+  return { jwt: token, org }
+}
+
+/**
+ * 这个账号属于哪些组织（按服务端返回的顺序）。
+ *
+ * ⚠ 浏览器登录能直接读到用户**当前选中**的组织（localStorage 里的
+ *   `MAGIC:user:organizationCode`），无头这条路没有那个信息 —— 所以只能把候选
+ *   全拿回来，让调用方逐个验，验不过再换下一个。
+ *
+ * ⚠ `authorization` 头**两种写法都要试**：前端这个接口是
+ *   `h.set("authorization", authorization)` —— 直接放 token，**没有 `Bearer ` 前缀**；
+ *   但平台其它接口（`/api/v1/flows/models` 等）走的是 `Bearer <jwt>` 并且能通。
+ *   登录拿到的是 438 字符的 `access_token`，和网页 localStorage 里那把 354 字符的不是
+ *   同一个东西，所以不能想当然 —— 两种都打，先成的算。
+ *   全失败时把每一步的真实原因记在模块变量里，供上层错误信息引用。
+ */
+let lastOrgProbeErrors = []
+export function orgProbeErrors() {
+  return lastOrgProbeErrors.slice()
+}
+
+export async function fetchOrgs(site, jwt) {
+  lastOrgProbeErrors = []
+
+  // 三个端点 × 两种 authorization 写法，全试一遍 —— 它们对令牌形态的宽容度不一样：
+  //   · login-data       前端是 h.set("authorization", token)（无 Bearer），但它同时
+  //                      接受 `Bearer <网页版 JWT>`（用本机 354 字符 JWT 实测通过）
+  //   · me/organizations 实测连 organization-code 头都不要，只认令牌
+  //   · auth/status      前端 bindMagicAuthorization 用它，返回 Array<MagicOrganization>
+  // 登录拿到的是 438 字符的 access_token，和网页 localStorage 那把 354 的不同，
+  // 所以不能想当然只打一个。
+  const probes = [
+    { tag: "login-data/Bearer", url: `${site.host}/api/v1/aggregation/login-data?teamshare_login_code=`, auth: `Bearer ${jwt}`, pick: (j) => j?.data?.auth_status ?? j?.auth_status },
+    { tag: "login-data/裸", url: `${site.host}/api/v1/aggregation/login-data?teamshare_login_code=`, auth: jwt, pick: (j) => j?.data?.auth_status ?? j?.auth_status },
+    { tag: "auth-status/Bearer", url: `${site.host}/api/v1/auth/status?login_code=`, auth: `Bearer ${jwt}`, pick: (j) => j?.data ?? j },
+    { tag: "auth-status/裸", url: `${site.host}/api/v1/auth/status?login_code=`, auth: jwt, pick: (j) => j?.data ?? j },
+    { tag: "me-organizations/Bearer", url: `${site.host}/api/v1/contact/accounts/me/organizations`, auth: `Bearer ${jwt}`, pick: (j) => j?.data?.items ?? j?.items },
+    { tag: "me-organizations/裸", url: `${site.host}/api/v1/contact/accounts/me/organizations`, auth: jwt, pick: (j) => j?.data?.items ?? j?.items },
+  ]
+
+  for (const p of probes) {
+    let res = null
+    try {
+      res = await fetch(p.url, {
+        headers: { authorization: p.auth, "user-agent": "magpie-magicrew-auth" },
+        signal: AbortSignal.timeout(20_000),
+      })
+    } catch (e) {
+      lastOrgProbeErrors.push(`${p.tag}：网络失败 ${String(e?.message ?? e).slice(0, 60)}`)
+      continue
+    }
+
+    const text = await res.text().catch(() => "")
+    if (!res.ok) {
+      lastOrgProbeErrors.push(`${p.tag}：HTTP ${res.status} ${text.slice(0, 70)}`)
+      continue
+    }
+    let j = null
+    try {
+      j = JSON.parse(text)
+    } catch {
+      lastOrgProbeErrors.push(`${p.tag}：非 JSON ${text.slice(0, 70)}`)
+      continue
+    }
+    if (j?.code !== 1000) {
+      lastOrgProbeErrors.push(`${p.tag}：code ${j?.code} ${j?.message ?? ""}`.trim())
+      continue
+    }
+    const list = p.pick(j)
+    if (!Array.isArray(list) || !list.length) {
+      lastOrgProbeErrors.push(`${p.tag}：200 但列表为空`)
+      continue
+    }
+    const orgs = parseOrgs(list)
+    if (orgs.length) return orgs
+    lastOrgProbeErrors.push(`${p.tag}：有 ${list.length} 项但取不到组织码`)
+  }
+  return []
+}
+
+function parseOrgs(list) {
+  // ⚠ 字段名是 `magic_organization_code`（实测）。`organization_code` 只在**外层**存在，
+  //   而且是空串 —— 认它就会拿到 ""。每项里另有 third_platform_ / teamshare_ 两份同值码。
+  const KEYS = [
+    "magic_organization_code",
+    "third_platform_organization_code",
+    "teamshare_organization_code",
+  ]
+  const out = []
+  for (const item of list) {
+    for (const key of KEYS) {
+      const v = item?.[key]
+      if (typeof v === "string" && /^[a-z0-9]{6,32}$/i.test(v) && !out.includes(v)) {
+        out.push(v)
+        break
+      }
+    }
+  }
+  return out
+}