magicrew-auth 0.3.18 → 0.3.24

package/src/headless.mjs

@@ -118,24 +118,73 @@ export async function finishSmsLogin(site, { mobile, stateCode = "+86", code, de
 
   const { jwt, org } = extractLoginCreds(json)
   if (!jwt) {
-    throw Object.assign(new Error("登录成功但响应里没找到 JWT —— 请把这条原始响应反馈给插件作者"), {
-      raw: json,
-    })
+    throw Object.assign(
+      new Error(`登录成功但响应里没找到可用令牌。响应结构：${describeShape(json)}`),
+      { raw: json },
+    )
   }
   // 响应里给了组织码就用它；没给就把该账号的组织**全列出来**，
-  // 由调用方逐个拿 fetchPoints 验（见 methods.mjs 的 completeSignIn）——
-  // 只取第一个是不够的：多组织账号会落到「列表第一个」而不是用户平时用的那个。
+  // 由调用方逐个拿 fetchPoints 验（见 methods.mjs 的 completeSignIn）。
   const orgs = org ? [org] : await fetchOrgs(site, jwt)
   if (!orgs.length) {
-    throw Object.assign(new Error("登录成功但拿不到组织码（该账号没有任何组织？）"), { raw: json })
+    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) {
-  // 只认 eyJ 三段式当 JWT；组织码优先取键名带 org 的那个
-  const { jwt, org } = extractCreds(json)
-  return { jwt, org }
+  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 }
 }
 
 /**
@@ -143,22 +192,80 @@ function extractLoginCreds(json) {
  *
  * ⚠ 浏览器登录能直接读到用户**当前选中**的组织（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) {
-  const res = await fetch(`${site.host}/api/v1/aggregation/login-data?teamshare_login_code=`, {
-    headers: {
-      authorization: `Bearer ${jwt}`,
-      "user-agent": "magpie-magicrew-auth",
-    },
-    signal: AbortSignal.timeout(20_000),
-  }).catch(() => null)
-  if (!res?.ok) return []
-  const j = await res.json().catch(() => null)
-  const list = j?.data?.auth_status ?? j?.auth_status ?? []
-  if (!Array.isArray(list)) return []
+  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 = [

package/src/hooks/loader.mjs

@@ -1,93 +1,234 @@
-// ④ auth.loader(getAuth) —— 请求接管
-//
-// 返回 baseURL / apiKey / headers / fetch(a,b)，magpie 拿它发真实请求。
-// 这是唯一能改请求体的地方。本项目用它干两件事：
-//
-//   · 国际站网关强制要 organization-code（国内站不要），不带就是
-//     HTTP 500 "Internal Server Error."（22 字节纯文本，不是 JSON）
-//   · 推理模型低于 512 的 max_tokens 会被 reasoning 吃光，content 返回空串
-//
-// ⚠ 不要在这里读流、不要重试换号、不要手拼 x-api-key ——
-//   前两件 magpie 做了，第三件看 SDK 包自动加。见 README「最小交付面」。
-
-import { ensureKey, accountOf } from "../keys.mjs"
-
-export function makeLoader(c) {
-  return async (getAuth) => {
-    const auth = await getAuth()
-    if (!auth) return {}
-    return {
-      baseURL: c.BASE,
-      apiKey: auth.access,
-      headers: { "user-agent": "MagicrewClient/1.0" },
-      async fetch(input, init) {
-        const fresh = await getAuth()
-        if (!fresh) throw new Error(`${c.SHORT} 未登录`)
-
-        // key 只有一个来源（src/keys.mjs）—— 服务端签一把顶一把，多入口必互相吊销
-        const key = await ensureKey(c, getAuth)
-        if (!key) throw new Error(`${c.SHORT} 未登录（拿不到可用的 key）`)
-        const account = accountOf(fresh)
-
-        const req = input instanceof Request ? input : null
-        const url =
-          typeof input === "string"
-            ? input
-            : input instanceof URL
-              ? input.toString()
-              : (req?.url ?? "")
-
-        const incoming = new Headers(init?.headers ?? req?.headers ?? {})
-        const headers = {
-          authorization: `Bearer ${key.apiKey}`,
-          "content-type": "application/json",
-        }
-        if (c.needsOrgOnGateway && fresh.org) headers["organization-code"] = fresh.org
-
-        for (const [k, v] of incoming) {
-          if (["authorization", "host", "content-length", "user-agent"].includes(k.toLowerCase())) continue
-          headers[k] = v
-        }
-
-        let body = init?.body
-        if (body === undefined && req) body = await req.text()
-
-        // 改写两处请求体，都为实测出来的：
-        //
-        // ① max_tokens 抬到 512
-        //    实测 glm-5.3-flash：64 → finish_reason:"length" 且 content:""
-        //                        512 → 正常出话（reasoning 208 / total 233）
-        //
-        // ② 流式请求补 stream_options.include_usage
-        //    magicrew 在 stream:true 下**默认不返回 usage**；补上之后，[DONE]
-        //    之前会多一条 {"choices":[],"usage":{...}} 的收尾 chunk。
-        //    magpie 新版靠这条收尾 chunk 判定「流正常结束了」——缺了它就报
-        //    「Stream ended without finish_reason」然后重试（实测 2026-10-27）。
-        //    控制台里看到的就是：模型请求重试 (3/5) · Stream ended without finish_reason
-        if (typeof body === "string" && body.includes('"stream"')) {
-          try {
-            const j = JSON.parse(body)
-            if (Number(j.max_tokens) > 0 && Number(j.max_tokens) < 512) j.max_tokens = 512
-            if (j.stream === true && !j.stream_options) {
-              j.stream_options = { include_usage: true }
-            }
-            body = JSON.stringify(j)
-          } catch {}
-        } else if (typeof body === "string" && body.includes('"max_tokens"')) {
-          try {
-            const j = JSON.parse(body)
-            if (Number(j.max_tokens) > 0 && Number(j.max_tokens) < 512) j.max_tokens = 512
-            body = JSON.stringify(j)
-          } catch {}
-        }
-
-        return fetch(url, {
-          method: init?.method ?? "POST",
-          headers,
-          body,
-          signal: init?.signal ?? req?.signal ?? AbortSignal.timeout(300_000),
-        })
-      },
-    }
-  }
-}
+// ④ auth.loader(getAuth) —— 请求接管
+//
+// 返回 baseURL / apiKey / headers / fetch(a,b)，magpie 拿它发真实请求。
+// 这是唯一能改请求体的地方。本项目用它干两件事：
+//
+//   · 国际站网关强制要 organization-code（国内站不要），不带就是
+//     HTTP 500 "Internal Server Error."（22 字节纯文本，不是 JSON）
+//   · 推理模型低于 512 的 max_tokens 会被 reasoning 吃光，content 返回空串
+//
+// ⚠ 不要在这里读流、不要重试换号、不要手拼 x-api-key ——
+//   前两件 magpie 做了，第三件看 SDK 包自动加。见 README「最小交付面」。
+
+import { ensureKey, accountOf } from "../keys.mjs"
+
+/**
+ * 把 JSON Schema 里的 `additionalProperties` **非布尔值**原地换成 `true`。
+ *
+ * 上游只认布尔值，收到任何对象都回 HTTP 400
+ * `{"error":{"message":"模型响应失败","code":4017}}`，整个请求被拒。
+ * 实测（2026-10-28，glm-5.3-flash 与 deepseek-v4.1-flash **两个模型完全一致**，
+ * 同一把 key、同一份请求、只改这一个字段）：
+ *
+ *   additionalProperties: 缺省              → 200
+ *   additionalProperties: false             → 200
+ *   additionalProperties: true              → 200
+ *   additionalProperties: {}                → 400 code 4017
+ *   additionalProperties: {type:"string"}   → 400 code 4017
+ *   additionalProperties: {type:"string",description:"x"} → 400 code 4017
+ *
+ * ⚠ 注意**不只是空对象**。有约束的 schema 形态（`{type:"string"}`）一样被拒 ——
+ * 这一点比"上游只认 true/false"更进一步：它根本不支持 schema 形态。
+ * 所以这里一律换成 `true`，属于**降级放宽**：
+ *
+ *   · `{}`            → `true`  语义等价（都是"任意，不加约束"）
+ *   · `{type:"string"}` → `true`  **不等价** —— 丢掉了"额外属性必须是 string"的约束
+ *
+ * 为什么接受这个不等价：上游无法表达它，保留原值就是整个请求失败。两害相权，
+ * 让工具调用能跑（可能多出未声明的字段）比让 agent 完全不可用要好。方向也安全 ——
+ * 是放宽不是收紧，不会让原本合法的调用被拒。
+ *
+ * 命中来源：ZCode / Claude Code 系客户端生成 schema 时爱写 `{}`；
+ * 一次真实请求里 54 个工具中的 `ExitPlanMode` 与 `CreateWorkflow` 就这么写。
+ * 客户端没写错（按规范 `{}` 与 `true` 等价），是上游兼容性不足，插件这边兜住。
+ *
+ * @returns {boolean} 有没有改到
+ */
+export function loosenAdditionalProperties(node) {
+  if (!node || typeof node !== "object") return false
+  if (Array.isArray(node)) {
+    let any = false
+    for (const n of node) if (loosenAdditionalProperties(n)) any = true
+    return any
+  }
+  let changed = false
+  for (const [k, v] of Object.entries(node)) {
+    if (k === "additionalProperties") {
+      // 布尔值上游认，原样留着（false 是"不许额外属性"，语义相反，绝对不能动）
+      if (typeof v !== "boolean") {
+        node[k] = true
+        changed = true
+      }
+      continue
+    }
+    if (v && typeof v === "object" && loosenAdditionalProperties(v)) changed = true
+  }
+  return changed
+}
+
+/**
+ * 上游的 JSON Schema 校验器不接受 `items: {}`，整轮请求回 HTTP 400：
+ *
+ *   {"error":{"code":null,"message":"超级麦吉: HTTP 400 请求错误: {\"error\":
+ *    {\"code\":\"InvalidParameter\",\"message\":\"tools.40.function.parameters/
+ *    properties/functions/items: invalid JSON Schema; check the schema
+ *    keywords and references Request id: ...\",\"param\":\"\",\"type\":
+ *    \"BadRequest\"}}","param":null,"type":"invalid_request_error"}}
+ *
+ * 报错只给路径，不说是哪个客户端。实测（2026-10-28，同一把 key、同一份请求、
+ * 只改 tools[0] 的这一处；国内站 `magicrew` 与国际站 `magicrew-intl` 逐行一致）：
+ *
+ *   items: 缺省                → 200
+ *   items: {}                  → 400 invalid JSON Schema
+ *   items: {description:"x"}   → 200   // 空对象才炸，不是"缺 type"
+ *   items: {type:"string"}     → 200
+ *   items: true                → 400 模型响应失败（另一种 400）
+ *   items: false               → 400 模型响应失败
+ *
+ * 为什么可以删：JSON Schema 里 `items` 的缺省值就是 `{}` —— "任意元素"。
+ * 所以 `items: {}` 删掉是**严格等价**（`true` 同理），不是降级放宽。
+ * `items: false` 表示"数组必须为空"，语义不同，不能删，原样留着。
+ *
+ * 命中来源：客户端用 `z.array(z.unknown())` / 动态函数列表生成工具 schema 时，
+ * 数组元素会序列化成 `{}`。一个真实请求里第 41 个工具的参数是
+ * `properties.functions.items: {}`，于是整轮失败。
+ *
+ * @returns {boolean} 有没有改到
+ */
+export function loosenEmptyItems(node) {
+  if (!node || typeof node !== "object") return false
+  if (Array.isArray(node)) {
+    let any = false
+    for (const n of node) if (loosenEmptyItems(n)) any = true
+    return any
+  }
+  let changed = false
+  for (const [k, v] of Object.entries(node)) {
+    if (k === "items") {
+      const emptyObject =
+        v && typeof v === "object" && !Array.isArray(v) && Object.keys(v).length === 0
+      if (emptyObject || v === true) {
+        delete node[k]
+        changed = true
+        continue
+      }
+    }
+    if (v && typeof v === "object" && loosenEmptyItems(v)) changed = true
+  }
+  return changed
+}
+
+/**
+ * 改写发往上游的请求体。**一次 parse，四处改写都在这**。
+ *
+ * 四处都是实测出来的，不是猜的：
+ *
+ * ① max_tokens 抬到 512
+ *    实测 glm-5.3-flash：64 → finish_reason:"length" 且 content:""
+ *                        512 → 正常出话（reasoning 208 / total 233）
+ *
+ * ② 流式请求补 stream_options.include_usage
+ *    magicrew 在 stream:true 下**默认不返回 usage**；补上之后，[DONE]
+ *    之前会多一条 {"choices":[],"usage":{...}} 的收尾 chunk。
+ *    magpie 新版靠这条收尾 chunk 判定「流正常结束了」——缺了它就报
+ *    「Stream ended without finish_reason」然后重试（实测 2026-10-27）。
+ *
+ * ③ tools 里的 additionalProperties: {} → true（见 looser 的注释）
+ *
+ * ④ tools 里的 items: {} → 删除（见 loosenEmptyItems 的注释）
+ *
+ * 没改到时返回原始字符串（省一次序列化 —— 54 个工具的请求体不小）。
+ *
+ * @param {unknown} raw
+ * @returns {unknown} 改了就是新字符串，没改就原样返回
+ */
+export function rewriteRequestBody(raw) {
+  if (typeof raw !== "string") return raw
+  // 粗筛：三个关键字一个都没有，就不必 parse
+  if (!/"stream"|"max_tokens"|"tools"/.test(raw)) return raw
+
+  let j
+  try {
+    j = JSON.parse(raw)
+  } catch {
+    return raw
+  }
+  if (!j || typeof j !== "object") return raw
+
+  let changed = false
+
+  if (Number(j.max_tokens) > 0 && Number(j.max_tokens) < 512) {
+    j.max_tokens = 512
+    changed = true
+  }
+
+  if (j.stream === true && !j.stream_options) {
+    j.stream_options = { include_usage: true }
+    changed = true
+  }
+
+  if (Array.isArray(j.tools)) {
+    for (const t of j.tools) {
+      const p = t?.function?.parameters
+      if (!p || typeof p !== "object") continue
+      if (loosenAdditionalProperties(p)) changed = true
+      if (loosenEmptyItems(p)) changed = true
+    }
+  }
+
+  return changed ? JSON.stringify(j) : raw
+}
+
+export function makeLoader(c) {
+  return async (getAuth) => {
+    const auth = await getAuth()
+    if (!auth) return {}
+    return {
+      baseURL: c.BASE,
+      apiKey: auth.access,
+      headers: { "user-agent": "MagicrewClient/1.0" },
+      async fetch(input, init) {
+        const fresh = await getAuth()
+        if (!fresh) throw new Error(`${c.SHORT} 未登录`)
+
+        // key 只有一个来源（src/keys.mjs）—— 服务端签一把顶一把，多入口必互相吊销
+        const key = await ensureKey(c, getAuth)
+        if (!key) throw new Error(`${c.SHORT} 未登录（拿不到可用的 key）`)
+        const account = accountOf(fresh)
+
+        const req = input instanceof Request ? input : null
+        const url =
+          typeof input === "string"
+            ? input
+            : input instanceof URL
+              ? input.toString()
+              : (req?.url ?? "")
+
+        const incoming = new Headers(init?.headers ?? req?.headers ?? {})
+        const headers = {
+          authorization: `Bearer ${key.apiKey}`,
+          "content-type": "application/json",
+        }
+        if (c.needsOrgOnGateway && fresh.org) headers["organization-code"] = fresh.org
+
+        for (const [k, v] of incoming) {
+          if (["authorization", "host", "content-length", "user-agent"].includes(k.toLowerCase())) continue
+          headers[k] = v
+        }
+
+        let body = init?.body
+        if (body === undefined && req) body = await req.text()
+
+        // 四处请求体改写，全在 rewriteRequestBody 里（那里有实测出处）
+        body = rewriteRequestBody(body)
+
+        return fetch(url, {
+          method: init?.method ?? "POST",
+          headers,
+          body,
+          signal: init?.signal ?? req?.signal ?? AbortSignal.timeout(300_000),
+        })
+      },
+    }
+  }
+}

package/src/hooks/methods.mjs

@@ -44,10 +44,17 @@ function kickoffFirstTask(c, jwt, org) {
  * 记组织 / 滚邀请码 / 补首任务 / 取昵称」这一串只有一份实现。
  *
  * `orgs` 是候选组织列表（无头那条路拿不到「用户当前选中的组织」，只能猜）。
- * 按顺序用 `fetchPoints` 真验一遍，第一个验得过才算 —— 多组织账号靠这个
- * 才不会落错地方。浏览器登录只有一个候选，行为不变。
+ * 按顺序用 `fetchPoints` 真验一遍，第一个验得过才算。
+ *
+ * ⚠ 别说这解决了「多组织选哪个」—— **它没解决，只是容错**：
+ *   账号所属的任何一个组织都能通过 `fetchPoints`（只要 JWT 有效），
+ *   所以「第一个验得过的」实际就是「列表第一个」。
+ *   真正的区别在浏览器登录那条路：它直接读 localStorage 里用户**当前选中**的那个。
+ *   服务端虽然给了 `is_current` 字段，但实测恒为 false（带不带 organization-code
+ *   头都一样），不能拿来判断。⇒ 多组织账号在无头这条路上会落到列表第一个组织，
+ *   这是已知限制，不是 bug。
  */
-async function completeSignIn(c, jwt, org, orgs = []) {
+async function completeSignIn(c, jwt, org, orgs = [], preferredAccountId = null) {
   const candidates = [org, ...orgs.filter((o) => o && o !== org)]
   let lastErr = null
   let picked = null
@@ -71,12 +78,23 @@ async function completeSignIn(c, jwt, org, orgs = []) {
   await rollInvite(c.id, jwt, picked, c.host)
   kickoffFirstTask(c, jwt, picked)
   const who = await fetchWho(jwt, picked, c.host).catch(() => null)
+
+  // ⚠ `accountId` 决定 magpie 是「替换」还是「新增」—— 同一个账号在两条登录路上
+  //   必须算出同一个字符串，否则就会出现「同一个号被加了两遍」。
+  //
+  //   真机踩过：浏览器登录拿到的是打码手机号 `189****051`（fetchWho 成功，
+  //   服务端只给打码号）；无头那条路 fetchWho 挂了（438 字符的 access_token
+  //   配 Bearer 头不通），于是兜底用了组织码 `h97gkbu8bruj` ⇒ 两条并存。
+  //
+  //   所以优先用**调用方明确给的** accountId（无头路径里就是它自己算出来的打码手机号），
+  //   `who.name` 只作为补充，组织码是最后一档 —— 它绝不该当账号名。
+  const accountId = preferredAccountId || who?.name || picked
   return {
     type: "success",
     access: key.apiKey,
     refresh: key.refreshToken,
     expires: Date.now() + 2 * 3600_000,
-    accountId: who?.name || picked,
+    accountId,
     uid: picked,
     jwt,
     org: picked,
@@ -109,7 +127,13 @@ export function makeMethods(c) {
       ],
       async authorize(inputs) {
         const phone = String(inputs?.phone || "").replace(/[\s-]/g, "")
-        if (!/^1\d{10}$/.test(phone)) return { type: "failed", error: "手机号不完整" }
+        // ⚠ 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")
@@ -195,7 +219,9 @@ export function makeMethods(c) {
         try {
           sent = await startSmsLogin(c, { mobile: phone })
         } catch (e) {
-          return { type: "failed", error: String(e?.message ?? e).slice(0, 500) }
+          // 同上：这里也不能 return failed —— 点「重试」会重新走 authorize，
+          // 返回没有 callback 的对象会让 magpie 崩在 `.callback()`
+          throw new Error(String(e?.message ?? e).slice(0, 500))
         }
 
         return {
@@ -220,7 +246,9 @@ export function makeMethods(c) {
               return { type: "failed", error: String(e?.message ?? e).slice(0, 500) }
             }
             try {
-              return await completeSignIn(c, creds.jwt, creds.org, creds.orgs)
+              // 传 masked（打码手机号）当 accountId —— 浏览器登录那条路拿到的也是
+              // 这个字符串，两边一致才不会把同一个号加成两条
+              return await completeSignIn(c, creds.jwt, creds.org, creds.orgs, masked)
             } catch (e) {
               return { type: "failed", error: `登录成功了，但换 key 失败：${String(e?.message ?? e).slice(0, 300)}` }
             }
@@ -407,8 +435,9 @@ export function makeMethods(c) {
       async authorize(inputs) {
         const jwt = String(inputs?.jwt || "").trim().replace(/^Bearer\s+/i, "")
         const org = String(inputs?.org || "").trim()
-        if (!jwt.startsWith("eyJ")) return { type: "failed", error: "不是 JWT" }
-        if (!org) return { type: "failed", error: "没填组织码" }
+        // 同一条规矩：authorize 里失败只抛异常，不返回 { type: "failed" }
+        if (!jwt.startsWith("eyJ")) throw new Error("不是 JWT")
+        if (!org) throw new Error("没填组织码")
 
         const result = (async () => {
           await fetchPoints(jwt, org, c.host)