magicrew-auth 0.3.26 → 0.3.28

package/src/hooks/loader.mjs

@@ -166,6 +166,168 @@ export function loosenEmptyItems(node) {
   })
 }
 
+/**
+ * 修 **`items` 子树内部**的 schema：上游的 JSON Schema 校验器对数组元素的
+ * schema 比对根节点**更严**，下面这些形态在 `items` 子树里一律 400：
+ *
+ *   anyOf / oneOf / allOf / not / const   → 400
+ *   if / then / else                      → 400
+ *   {}（空 schema）                       → 400
+ *
+ * ⚠ 同样形态放在**顶层 parameters** 里上游**收**（200）—— 只有 `items` 子树
+ * 里才炸。所以限制必须精确落在 `items` 之下，不能全局摊平 union。
+ *
+ * 实测（2026-10-28~29，直打国内站 `i-magic-service.letsmagic.cn`，
+ * deepseek-v4.1-flash，同一把 key、同一份请求，只改这一个字段；
+ * `_probe/items-subtree-upstream.mjs` 可复跑）：
+ *
+ *   items 内部 {x:{anyOf:[{type:"string"},{type:"null"}]}} → 400
+ *   items 内部 {x:{oneOf:[…]}}                            → 400
+ *   items 内部 {x:{allOf:[…]}}                            → 400
+ *   items 内部 {x:{not:{type:"string"}}}                  → 400
+ *   items 内部 {x:{const:"a"}}                            → 400
+ *   items 内部 {x:{if:…,then:…}}                          → 400
+ *   items 内部 {x:{}}                                     → 400
+ *   items 内部 {x:{type:["object","string",…,"null"]}}    → 200   ← 「任意值」的合法写法
+ *   items 内部 {x:{type:"object"}}                        → 200
+ *   items 内部 {x:{type:"string",pattern:"^a$",enum:[…]}} → 200
+ *   items 内部 {x:{$ref:"#/$defs/s"}}, $defs 同层        → 200
+ *   items 是数组（tuple 形式）    国内站 → 200，**国际站 → 400**（两站不一致）
+ *   顶层   {x:{anyOf:…}} / {x:{const:…}} / {x:{not:…}} / {x:{}} → 200
+ *   （国内站 `i-magic-service.letsmagic.cn` 与国际站 `magic-service.magicrew.ai`
+ *     逐条对比过：除 tuple 形式外结论一致）
+ *
+ * 命中来源：**MCP 服务器**的工具 schema。REA MCP（mcp__rea__build_call_path 等
+ * 7 个工具）的 `functions` 数组参数，元素 schema 用了
+ * `anyOf: [{...}, {type:"null"}]`（可选参数的标准写法）、`oneOf`，还有
+ * `{}` 空 schema —— 一份 65 工具的请求里就有 7 个工具中招，整轮 400。
+ *
+ * 修法（全部是**降级放宽**，方向安全：宁可约束松一点，也不要整轮失败）：
+ *
+ *   anyOf / oneOf / allOf  → 取一个分支内联（**优先非纯 null 的分支**：
+ *                              `anyOf:[{…},{type:"null"}]` 取前者；反过来写时
+ *                              照抄第一个会把「可选」压成「只能 null」，那是收紧）
+ *   not / const / if+then+else → 删除（无等价物；删掉就是放宽）
+ *   {}                     → `{type:["object","string","number","boolean","array","null"]}`
+ *                             （六种 JSON 类型全覆盖 = 任意值，与 `{}` 严格等价；
+ *                              **不能**用 `{type:"object"}` —— 那会把「任意」收紧成「只能是对象」）
+ *
+ * ⚠ 两个容易漏的坑（都踩过）：
+ *   1. 删除 `not` / `const` 后节点可能变成 `{}` —— 必须在删除后再查一次空对象，
+ *      否则改完仍是 400（PR #10 初版就漏在这里，`not`/`const` 两例改写后仍 400）。
+ *   2. `items` 子树里 `{}` 和 `true` 都被拒，所以「任意值」只能落成显式 type 数组。
+ *
+ * ⚠ 只走 `items` 子树：顶层 parameters 的 union 是上游**收**的，动了它
+ * 会白白丢掉约束。
+ *
+ * @returns {boolean} 有没有改到
+ */
+export function loosenItemsSchema(node) {
+  let changed = false
+  // 用 walkSchema 找**每一个** schema 位置上的 items（它只进入真正的 schema
+  // 位置：properties 的值、union 的分支、items 的值……不碰 enum/default 的字面值）。
+  walkSchema(node, (n) => {
+    if (!Object.hasOwn(n, "items")) return false
+    const v = n.items
+    // tuple 形式（draft-04）：`items` 是 schema **数组**。
+    // 两站行为不一致 —— 国内站收、**国际站拒**（`[{"type":"string"}] is not of
+    // type 'object'`），实测见 `_probe/items-subtree-upstream.mjs`。
+    // 数组里的逐位约束在改写里表达不了（`anyOf` 在这层就是 400），
+    // 只能整体落成「任意值」—— 纯放宽，不会让原本合法的调用被拒。
+    if (Array.isArray(v)) {
+      n.items = { type: [...ANY_SCHEMA_TYPE] }
+      changed = true
+      return false
+    }
+    if (!v || typeof v !== "object") return false
+    if (fixItemsSubtree(v)) changed = true
+    return false
+  })
+  return changed
+}
+
+// 空 schema 在 JSON Schema 里等价于 `true` = 接受任意 JSON 值。但上游对
+// `items` 子树里的 `{}` 和 `true` 都拒，只能落成显式的「任意类型」schema。
+const ANY_SCHEMA_TYPE = ["object", "string", "number", "boolean", "array", "null"]
+
+/** 把一个空 schema 节点原地改成「任意值」。返回是否真的改到（只对空对象生效）。 */
+function toAnySchema(n) {
+  if (Object.keys(n).length > 0) return false
+  n.type = [...ANY_SCHEMA_TYPE]
+  return true
+}
+
+/** 分支是不是只声明了 null —— 取它内联会把「可选」压成「只能 null」（收紧） */
+function isNullOnly(branch) {
+  if (!branch || typeof branch !== "object" || Array.isArray(branch)) return false
+  if (branch.type === "null") return true
+  return Array.isArray(branch.type) && branch.type.length === 1 && branch.type[0] === "null"
+}
+
+/**
+ * 在 `items` 子树里就地修：union 摊平、const/not/if 删除、空 schema 换形状。
+ *
+ * 递归同样遵守 schema 位置纪律（见 {@link SCHEMA_MAPS} / {@link SCHEMA_LIST} /
+ * {@link SCHEMA_ONE}）：`enum` / `default` / `examples` 里的字面值不是 schema，
+ * 不能动。
+ *
+ * @returns {boolean} 有没有改到
+ */
+function fixItemsSubtree(n) {
+  if (!n || typeof n !== "object" || Array.isArray(n)) return false
+  let dirty = false
+
+  // 空 schema {} → 显式「任意类型」（与 {} 严格等价）
+  if (toAnySchema(n)) return true
+
+  for (const [k, v] of Object.entries(n)) {
+    if (k === "anyOf" || k === "oneOf" || k === "allOf") {
+      if (!Array.isArray(v) || v.length === 0) {
+        delete n[k]
+        dirty = true
+        continue
+      }
+      // 优先第一个非纯 null 的分支（顺序反过来时不至于把可选压成「只能 null」）
+      const branch =
+        v.find((b) => b && typeof b === "object" && !Array.isArray(b) && !isNullOnly(b)) ??
+        v.find((b) => b && typeof b === "object" && !Array.isArray(b))
+      delete n[k]
+      dirty = true
+      if (branch) {
+        // 分支本身也可能带 union / 空 schema ⇒ 先递归修，再内联
+        if (fixItemsSubtree(branch)) dirty = true
+        Object.assign(n, branch)
+      }
+      continue
+    }
+    if (k === "not" || k === "const" || k === "if" || k === "then" || k === "else") {
+      delete n[k]
+      dirty = true
+      continue
+    }
+    // 其余按 schema 位置递归
+    if (SCHEMA_MAPS.has(k) && !Array.isArray(v)) {
+      for (const child of Object.values(v)) if (fixItemsSubtree(child)) dirty = true
+      continue
+    }
+    if (SCHEMA_LIST.has(k) && Array.isArray(v)) {
+      for (const child of v) if (fixItemsSubtree(child)) dirty = true
+      continue
+    }
+    if (SCHEMA_ONE.has(k)) {
+      if (Array.isArray(v)) {
+        for (const child of v) if (fixItemsSubtree(child)) dirty = true
+      } else if (fixItemsSubtree(v)) {
+        dirty = true
+      }
+    }
+  }
+  // 删除 not/const/if… 之后节点可能变空 —— 空 schema 在 items 子树里仍然 400，
+  // 必须补成「任意值」。
+  if (toAnySchema(n)) dirty = true
+  return dirty
+}
+
 /**
  * 改写发往上游的请求体。**一次 parse，四处改写都在这**。
  *
@@ -221,6 +383,7 @@ export function rewriteRequestBody(raw) {
       if (!p || typeof p !== "object") continue
       if (loosenAdditionalProperties(p)) changed = true
       if (loosenEmptyItems(p)) changed = true
+      if (loosenItemsSchema(p)) changed = true
     }
   }
 

package/src/hooks/methods.mjs

@@ -1,16 +1,26 @@
 // ② auth.methods[] —— 登录
 //
-// 两条路，按可靠性排：
+// 四条路，按可靠性排：
 //
-//   ① 浏览器登录（默认，零输入）：插件自己拉起一个能被 CDP 看进去的浏览器，
+//   ① 手机号验证码（零浏览器）：识图模型过旋转验证 → 发短信 → 用户填码。
+//   ② 邮箱验证码：同一条链，只有标识字段和两个端点不同（见下面 makeCodeMethod）。
+//   ③ 浏览器登录（默认零输入）：插件自己拉起一个能被 CDP 看进去的浏览器，
 //      用户在官方页里用任何方式登，登录成功那一刻插件把 localStorage 读走。
 //      拉不起来就降级成「magpie 开系统浏览器 + 用户粘一行 Console」。
-//   ② 登录态（JWT + 组织码）：手填两个字段，兜底用。
+//   ④ 登录态（JWT + 组织码）：手填两个字段，兜底用。
 //
-// ⚠ 两条铁律：
+// ⚠ 三条铁律：
 //   · authorize() 必须立刻返回 —— 真正等用户的是 callback()，死等会和 magpie 互锁
 //   · opened: true 的语义是「我自己已经开过页面了，你别再开」；
 //     只返回 url 让它去开的，**不许**传 opened
+//   · authorize() 里失败只能抛异常，**不能** return { type: "failed" } ——
+//     magpie 把它的返回值当「登录流程对象」，会去调 `.callback()`，于是崩在一句
+//     `callback is not a function` 上（实测触发路径：callback 失败 → 用户点「重试」
+//     → 重新调 authorize → 又走到失败分支 → 崩）
+//
+// ⚠ 数组顺序 = magpie 登录方式列表里的顺序，所以**按站点分**：
+//   国际站（magicrew-intl）邮箱在前 —— 那边用户大多是邮箱注册的；
+//   国内站手机号在前。
 
 import {
   issueGatewayKey,
@@ -22,7 +32,7 @@ import { inviteToUse, readSession, writeSession, noteLoginFailure, noteOrg, read
 import { readLocalCreds } from "../local-browser.mjs"
 import { CLIP_HINT, clipboardText, parseCreds, pollClipboard } from "../clipboard.mjs"
 import { readVisionModel } from "../vision.mjs"
-import { finishSmsLogin, startSmsLogin } from "../headless.mjs"
+import { finishCodeLogin, startCodeLogin } from "../headless.mjs"
 
 /**
  * 账号刚加进来（登录成功）→ 一次性把「首次 AI 工作 / 首个对话」补掉。
@@ -46,6 +56,16 @@ function kickoffFirstTask(c, jwt, org) {
  * `orgs` 是候选组织列表（无头那条路拿不到「用户当前选中的组织」，只能猜）。
  * 按顺序用 `fetchPoints` 真验一遍，第一个验得过才算。
  *
+ * 后两个参数只影响**卡片上显示的名字**，但选错会让同一个号在两条登录路上
+ * 算出不同的 accountId，magpie 就把同一个号加成两条（真机踩过）。三档优先级：
+ *
+ *   preferredAccountId → who.name（服务端给的手机号/邮箱/昵称）→ fallbackAccountId → 组织码
+ *
+ *   · 手机号验证码那条传 preferred —— 服务端只回打码号（`189****051`），
+ *     得由我们自己把它固定成同一个字符串，两条路才一致
+ *   · 邮箱验证码那条传 fallback —— 邮箱不需要打码；who 成功时优先用 who，
+ *     这样和浏览器登录那条路算出来的是同一个
+ *
  * ⚠ 别说这解决了「多组织选哪个」—— **它没解决，只是容错**：
  *   账号所属的任何一个组织都能通过 `fetchPoints`（只要 JWT 有效），
  *   所以「第一个验得过的」实际就是「列表第一个」。
@@ -54,7 +74,7 @@ function kickoffFirstTask(c, jwt, org) {
  *   头都一样），不能拿来判断。⇒ 多组织账号在无头这条路上会落到列表第一个组织，
  *   这是已知限制，不是 bug。
  */
-async function completeSignIn(c, jwt, org, orgs = [], preferredAccountId = null) {
+async function completeSignIn(c, jwt, org, orgs = [], preferredAccountId = null, fallbackAccountId = null) {
   const candidates = [org, ...orgs.filter((o) => o && o !== org)]
   let lastErr = null
   let picked = null
@@ -85,10 +105,7 @@ async function completeSignIn(c, jwt, org, orgs = [], preferredAccountId = null)
   //   真机踩过：浏览器登录拿到的是打码手机号 `189****051`（fetchWho 成功，
   //   服务端只给打码号）；无头那条路 fetchWho 挂了（438 字符的 access_token
   //   配 Bearer 头不通），于是兜底用了组织码 `h97gkbu8bruj` ⇒ 两条并存。
-  //
-  //   所以优先用**调用方明确给的** accountId（无头路径里就是它自己算出来的打码手机号），
-  //   `who.name` 只作为补充，组织码是最后一档 —— 它绝不该当账号名。
-  const accountId = preferredAccountId || who?.name || picked
+  const accountId = preferredAccountId || who?.name || fallbackAccountId || picked
   return {
     type: "success",
     access: key.apiKey,
@@ -101,161 +118,235 @@ async function completeSignIn(c, jwt, org, orgs = [], preferredAccountId = null)
   }
 }
 
-export function makeMethods(c) {
-  return [
-    {
-      // 手机号 + 短信验证码，**不开浏览器**。
-      //
-      // 卡点从来不是协议，是那张「拖动滑块使图片角度为正」的图。现在的做法：
-      // 用 magpie 设置里用户自己选的识图模型（settings.json 的 vision）
-      // 判断「主体上方向指向钟面几点」，再换算成拖动角度 —— 实测 120° 的图判出 122°，
-      // 而服务端容差 ±10°，够用。
-      //
-      // 没配识图模型时不在这里瞎猜（猜中概率只有 ~5.6%，会先撞「验证提交过于频繁」），
-      // 而是让这条方法直接报错并指路 —— 详见下面那段说明。
-      type: "oauth",
-      label: `${c.SHORT} 手机号验证码`,
-      prompts: [
-        {
-          type: "text",
-          key: "phone",
-          message: "手机号",
-          placeholder: "13800138000",
-          validate: (v) =>
-            /^1\d{10}$/.test(String(v || "").replace(/[\s-]/g, "")) ? undefined : "11 位手机号，只要数字",
-        },
-      ],
-      async authorize(inputs) {
-        const phone = String(inputs?.phone || "").replace(/[\s-]/g, "")
-        // ⚠ authorize() 里**不能**返回 { type: "failed" }：magpie 把这里的返回值当作
-        //   「登录流程对象」，会去调它的 `.callback()` —— 少了这个函数就是一句
-        //   `callback is not a function`，用户只看到莫名其妙的报错。
-        //   实测触发路径：callback 里失败 → magpie 显示「重试」 → 点重试会**重新调
-        //   authorize** → 这次走到这条失败分支 → 返回没有 callback 的对象 → 崩。
-        //   ⇒ authorize 里失败一律抛异常。
-        if (!/^1\d{10}$/.test(phone)) throw new Error("手机号不完整")
-
-        const vision = readVisionModel()
-        const masked = phone.replace(/^(\d{3})\d{4}(\d{4})$/, "$1****$2")
-
-        if (!vision) {
-          // 没有识图模型 → 回退到浏览器：打不开就不硬撑。
-          //
-          // 为什么不在这里瞎猜角度：容差 ±10° 意味着瞎猜命中率只有 ~5.6%（20/360），
-          // 平均要试十几次，而服务端有「验证提交过于频繁」和「验证次数已超限」两道风控 ——
-          // 等不到猜中，先被限流。所以老老实实让用户转那一下。
-          let browser = null
-          let why = ""
-          try {
-            browser = await import("../browser-login.mjs")
-          } catch (e) {
-            why = `浏览器登录模块加载失败：${String(e?.message ?? e).slice(0, 200)}`
-            noteLoginFailure(c.id, why)
-          }
+/** 邮箱的粗校验。别搬 RFC 那个怪物正则 —— 服务端还会再验一次 */
+const EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]{2,}$/
+
+/**
+ * 「验证码登录」——手机号与邮箱共用一份实现。
+ *
+ * 两条链的协议**完全一样**：取图 → 识图判角度 → 过旋转验证 → 发码 → 用户填码 →
+ * 换登录态。差异只有三处，而且都已收敛进 captcha.mjs / headless.mjs 按 ident 分派：
+ *
+ *   · 问用户要什么：11 位手机号 / 邮箱
+ *   · 发码端点：`/v4/user/send-sms` / `/v4/user/send-email`
+ *   · 换登录态：`/v4/user/login`（验证码字段叫 `code`）/
+ *              `/v4/user/login-email`（字段叫 `captcha`）
+ *
+ * 所以这里只写一份、传 kind。哪天被复制成两份，下次改超时或改文案必然只改一份。
+ *
+ * 卡点从来不是协议，是那张「拖动滑块使图片角度为正」的图：用 magpie 设置里用户
+ * 自己选的识图模型（settings.json 的 vision）判「主体上方向指向钟面几点」，再换算
+ * 成拖动角度 —— 实测 120° 的图判出 122°，而服务端容差 ±10°，够用。
+ *
+ * 没配识图模型时**不在这里瞎猜**（猜中概率只有 ~5.6%，会先撞「验证提交过于频繁」），
+ * 而是回退到浏览器登录，让用户自己转那一下。
+ *
+ * @param {object} c     站点闭包（id / SHORT / web / host）
+ * @param {"mobile"|"email"} kind
+ */
+function makeCodeMethod(c, kind) {
+  const isEmail = kind === "email"
+  const what = isEmail ? "邮箱" : "手机号"
+  /** 官方登录页上那个 tab 的名字 —— 回退到浏览器时要说清楚点哪个 */
+  const tab = isEmail ? "邮箱登录（Email）" : "手机登录（Phone）"
 
-          const inviteCode = inviteToUse(c.id)
-          const url = inviteCode
-            ? `${c.web}/login?invitation=${encodeURIComponent(inviteCode)}`
-            : `${c.web}/login`
-          const hostFragment = new URL(c.web).hostname
+  /** 用户填的那一项 → 之后每个请求都要带的标识字段 */
+  const identOf = (inputs) =>
+    isEmail
+      ? { email: String(inputs?.email || "").trim() }
+      : { mobile: String(inputs?.phone || "").replace(/[\s-]/g, ""), stateCode: "+86" }
 
-          const session = browser
-            ? await browser.launchLoginBrowser(url).catch((e) => {
-                why = String(e?.message ?? e).slice(0, 300)
-                noteLoginFailure(c.id, `launch: ${why}`)
-                return null
-              })
-            : null
+  /**
+   * 给用户看的那个标识。
+   * 手机号打码（服务端自己也是这么回的），邮箱原样 —— 邮箱没有打码这回事，
+   * 而且它正好是浏览器登录那条路上 `who.name` 会给出的字符串。
+   */
+  const displayOf = (ident) =>
+    isEmail ? ident.email : String(ident.mobile).replace(/^(\d{3})\d{4}(\d{4})$/, "$1****$2")
 
-          return {
-            url,
-            ...(session ? { opened: true } : {}),
-            instructions: session
-              ? `没有配置识图模型，那个「拖动滑块使图片角度为正」得你自己转一下 —— 已经用 ${session.name || "浏览器"} 打开了登录页。\n` +
-                `在里面选「手机登录」，填 ${masked}，把图片转正、收到验证码后填进去；登录完成这个窗口会自动接上，不用回来点任何东西。\n` +
-                `（想全自动的话：magpie 设置 → 识图模型，选一个能看图的，下次就只需要填手机号和验证码。）`
-              : `没能自己拉起浏览器${why ? `（${why}）` : "（本机没找到 Chromium 内核浏览器）"}，已改用系统浏览器打开登录页。\n` +
-                `登录完成后，在页面里按 F12 → Console 粘这一行：\n${CLIP_HINT}`,
-            method: "auto",
-            async callback() {
-              let got = null
-              if (session && browser) {
-                got = await browser.waitForCreds(session, hostFragment).catch(() => null)
-                await browser.closeSession(session).catch(() => {})
-              }
-              if (!got && !session) {
-                got = await pollClipboard({ skip: "" }).catch(() => null)
-              }
-              if (!got) {
-                return {
-                  type: "failed",
-                  error: session
-                    ? "浏览器开着了，但 5 分钟内没在里面读到登录状态 —— 是还没登完，还是登的不是这个站点？"
-                    : "5 分钟内没拿到登录状态。可以改用「登录态（JWT + 组织码）」那条备选。",
-                }
-              }
-              try {
-                if (!got.org) throw new Error("只拿到 JWT，没有组织码")
-                return await completeSignIn(c, got.jwt, got.org)
-              } catch (e) {
-                return { type: "failed", error: String(e?.message ?? e).slice(0, 500) }
-              }
-            },
+  const looksInvalid = (ident) => (isEmail ? !EMAIL_RE.test(ident.email) : !/^1\d{10}$/.test(ident.mobile))
+
+  return {
+    type: "oauth",
+    label: `${c.SHORT} ${what}验证码`,
+    prompts: [
+      isEmail
+        ? {
+            type: "text",
+            key: "email",
+            message: "邮箱",
+            placeholder: "you@example.com",
+            validate: (v) =>
+              EMAIL_RE.test(String(v || "").trim()) ? undefined : "填一个完整邮箱，例如 you@example.com",
           }
-        }
+        : {
+            type: "text",
+            key: "phone",
+            message: "手机号",
+            placeholder: "13800138000",
+            validate: (v) =>
+              /^1\d{10}$/.test(String(v || "").replace(/[\s-]/g, "")) ? undefined : "11 位手机号，只要数字",
+          },
+    ],
+    async authorize(inputs) {
+      const ident = identOf(inputs)
+      // ⚠ 这里是 authorize，失败只能抛异常，不能返回 { type: "failed" }（见文件头铁律）
+      if (looksInvalid(ident)) throw new Error(`${what}不完整`)
 
-        // 邀请码两条路都要出现：登录页的 URL，以及最终注册时服务端读到的那份。
-        // ⚠ 无头这条路**没有**「打开带邀请码的页面」这一步，所以邀请码只能靠
-        //   `redirect` 传 —— 网页表单的初始值里 redirect 就是 window.location.href，
-        //   服务端从它上面取 `?invitation=`。少了它，新注册的号就没有邀请关系。
-        const inviteCode = inviteToUse(c.id)
-        const loginUrl = inviteCode
-          ? `${c.web}/login?invitation=${encodeURIComponent(inviteCode)}`
-          : `${c.web}/login`
+      const shown = displayOf(ident)
+
+      // 邀请码两条路都要出现：登录页的 URL，以及最终注册时服务端读到的那份。
+      // ⚠ 无头这条路**没有**「打开带邀请码的页面」这一步，所以邀请码只能靠
+      //   `redirect` 传 —— 网页表单的初始值里 redirect 就是 window.location.href，
+      //   服务端从它上面取 `?invitation=`。少了它，新注册的号就没有邀请关系。
+      const inviteCode = inviteToUse(c.id)
+      const loginUrl = inviteCode
+        ? `${c.web}/login?invitation=${encodeURIComponent(inviteCode)}`
+        : `${c.web}/login`
 
-        // 发短信这一步最慢（过验证最多试 3 张图、每张问两遍模型）。
-        // 但必须等它结束才能告诉用户「验证码已发出」—— 所以这里不甩到 callback 里。
-        let sent
+      /**
+       * 需要过图、但用户没配识图模型 → 回退到浏览器，让他自己转那一下。
+       *
+       * ⚠ 只有**这个号还没注册**时才该走到这里：已注册的号服务端根本不发旋转图，
+       *   `startCodeLogin` 会直接发码（见 headless.mjs 里那段说明）。
+       *
+       * 为什么不在这里瞎猜角度：容差 ±10° 意味着瞎猜命中率只有 ~5.6%（20/360），
+       * 平均要试十几次，而服务端有「验证提交过于频繁」和「验证次数已超限」两道风控 ——
+       * 等不到猜中，先被限流。所以老老实实让用户转那一下。
+       */
+      async function browserFallback() {
+        const url = loginUrl
+        const hostFragment = new URL(c.web).hostname
+        let browser = null
+        let why = ""
         try {
-          sent = await startSmsLogin(c, { mobile: phone })
+          browser = await import("../browser-login.mjs")
         } catch (e) {
-          // 同上：这里也不能 return failed —— 点「重试」会重新走 authorize，
-          // 返回没有 callback 的对象会让 magpie 崩在 `.callback()`
-          throw new Error(String(e?.message ?? e).slice(0, 500))
+          why = `浏览器登录模块加载失败：${String(e?.message ?? e).slice(0, 200)}`
+          noteLoginFailure(c.id, why)
         }
 
+        const session = browser
+          ? await browser.launchLoginBrowser(url).catch((e) => {
+              why = String(e?.message ?? e).slice(0, 300)
+              noteLoginFailure(c.id, `launch: ${why}`)
+              return null
+            })
+          : null
+
         return {
-          url: loginUrl,
-          instructions:
-            `验证码已发送到 ${masked}。\n` +
-            `旋转验证由识图模型（${vision}）自动通过，试了 ${sent.rounds} 张图。\n` +
-            `把收到的 6 位验证码填进下面的框就行。`,
-          method: "code",
-          // ⚠ 必须是 true。这条链路**全在后台走完**，不需要任何浏览器；
-          //   opened: false 会让 magpie 拿 url 去开**系统默认浏览器** —— 而那个浏览器里
-          //   往往本来就登着这个站，用户看到的是已登录界面，根本进不了「添加新号」，
-          //   还会以为插件把他登进了旧账号。这正是浏览器登录那条路修过的坑。
-          opened: true,
-          async callback(code) {
-            const c0 = String(code || "").replace(/\D/g, "")
-            if (c0.length < 4) return { type: "failed", error: "验证码是 4~8 位数字" }
-            let creds
-            try {
-              creds = await finishSmsLogin(c, { mobile: phone, code: c0, redirect: loginUrl })
-            } catch (e) {
-              return { type: "failed", error: String(e?.message ?? e).slice(0, 500) }
+          url,
+          ...(session ? { opened: true } : {}),
+          instructions: session
+            ? `没有配置识图模型，那个「拖动滑块使图片角度为正」得你自己转一下 —— 已经用 ${session.name || "浏览器"} 打开了登录页。\n` +
+              `在里面选「${tab}」，填 ${shown}，把图片转正、收到验证码后填进去；登录完成这个窗口会自动接上，不用回来点任何东西。\n` +
+              `（想全自动的话：magpie 设置 → 识图模型，选一个能看图的，下次就只需要填${what}和验证码。）`
+            : `没能自己拉起浏览器${why ? `（${why}）` : "（本机没找到 Chromium 内核浏览器）"}，已改用系统浏览器打开登录页。\n` +
+              `登录完成后，在页面里按 F12 → Console 粘这一行：\n${CLIP_HINT}`,
+          method: "auto",
+          async callback() {
+            let got = null
+            if (session && browser) {
+              got = await browser.waitForCreds(session, hostFragment).catch(() => null)
+              await browser.closeSession(session).catch(() => {})
+            }
+            if (!got && !session) {
+              got = await pollClipboard({ skip: "" }).catch(() => null)
+            }
+            if (!got) {
+              return {
+                type: "failed",
+                error: session
+                  ? "浏览器开着了，但 5 分钟内没在里面读到登录状态 —— 是还没登完，还是登的不是这个站点？"
+                  : "5 分钟内没拿到登录状态。可以改用「登录态（JWT + 组织码）」那条备选。",
+              }
             }
             try {
-              // 传 masked（打码手机号）当 accountId —— 浏览器登录那条路拿到的也是
-              // 这个字符串，两边一致才不会把同一个号加成两条
-              return await completeSignIn(c, creds.jwt, creds.org, creds.orgs, masked)
+              if (!got.org) throw new Error("只拿到 JWT，没有组织码")
+              return await completeSignIn(c, got.jwt, got.org)
             } catch (e) {
-              return { type: "failed", error: `登录成功了，但换 key 失败：${String(e?.message ?? e).slice(0, 300)}` }
+              return { type: "failed", error: String(e?.message ?? e).slice(0, 500) }
             }
           },
         }
-      },
+      }
+
+      // 发码这一步最慢（要给新号过验证时最多试 4 张图、每张问两遍模型）。
+      // 但必须等它结束才能告诉用户「验证码已发出」—— 所以这里不甩到 callback 里。
+      let sent
+      try {
+        sent = await startCodeLogin(c, ident)
+      } catch (e) {
+        if (e?.code === "no-vision-model") {
+          // ⚡ 只有这一种情况才回退到浏览器：这个号**还没注册**（服务端给了旋转图），
+          //    而用户没配识图模型。已注册的号走不到这里 —— 服务端不出图。
+          return browserFallback()
+        }
+        // 其余一律抛：authorize 里 return failed 会让 magpie 崩在 `.callback()`
+        throw new Error(String(e?.message ?? e).slice(0, 500))
+      }
+
+      return {
+        url: loginUrl,
+        instructions: sent.skippedCaptcha
+          ? `验证码已发送到 ${shown}。\n` +
+            `这个号服务端那边已经注册过，旋转验证直接放行 —— 这一环跳过了，识图模型这次也用不上。\n` +
+            `把收到的 6 位验证码填进下面的框就行。`
+          : `验证码已发送到 ${shown}。\n` +
+            `旋转验证由识图模型（${readVisionModel()}）自动通过，试了 ${sent.rounds} 张图。\n` +
+            `把收到的 6 位验证码填进下面的框就行。`,
+        method: "code",
+        // ⚠ 必须是 true。这条链路**全在后台走完**，不需要任何浏览器；
+        //   opened: false 会让 magpie 拿 url 去开**系统默认浏览器** —— 而那个浏览器里
+        //   往往本来就登着这个站，用户看到的是已登录界面，根本进不了「添加新号」，
+        //   还会以为插件把他登进了旧账号。这正是浏览器登录那条路修过的坑。
+        opened: true,
+        async callback(code) {
+          const c0 = String(code || "").replace(/\D/g, "")
+          if (c0.length < 4) return { type: "failed", error: "验证码是 4~8 位数字" }
+          let creds
+          try {
+            creds = await finishCodeLogin(c, { ...ident, code: c0, redirect: loginUrl })
+          } catch (e) {
+            return { type: "failed", error: String(e?.message ?? e).slice(0, 500) }
+          }
+          try {
+            // 手机号：把打码号钉成 accountId（浏览器登录那条路拿到的也是这个字符串）；
+            // 邮箱：优先让 who 决定（那才是浏览器登录会给出的一致值），who 挂了才退回邮箱
+            return await completeSignIn(
+              c,
+              creds.jwt,
+              creds.org,
+              creds.orgs,
+              isEmail ? null : shown,
+              isEmail ? ident.email : null,
+            )
+          } catch (e) {
+            return { type: "failed", error: `登录成功了，但换 key 失败：${String(e?.message ?? e).slice(0, 300)}` }
+          }
+        },
+      }
     },
+  }
+}
+
+export function makeMethods(c) {
+  // 顺序 = magpie 登录方式列表里的顺序。
+  //
+  // ⚠ **邮箱验证码只有国际站有**，国内站不给。实测两件事：
+  //   ① www.letsmagic.cn/login 的登录方式只有 微信 / 苹果 / 密码 / 手机 / 私有部署，
+  //      **没有邮箱**（国际站 www.magicrew.ai/login 才有 `switch-to-email`）；
+  //   ② 同一个发信请求，国内站 `/v4/user/send-email` 回 `2000 服务异常，请联系管理员`，
+  //      国际站回 `1000 请求成功`。
+  //   国内站既然没有邮箱入口，也就不存在邮箱注册的账号 —— 把这条方法摆出来，
+  //   只会让用户填完邮箱撞一个看不懂的错。
+  const codeMethods =
+    c.id === "magicrew-intl"
+      ? [makeCodeMethod(c, "email"), makeCodeMethod(c, "mobile")]
+      : [makeCodeMethod(c, "mobile")]
+
+  return [
+    ...codeMethods,
 
     {
       type: "oauth",