magicrew-auth 0.3.6 → 0.3.8

package/src/hooks/checkin.mjs

@@ -7,11 +7,18 @@
 //
 // 签到逻辑在独立模块里**按需加载**：它挂了，登录/模型/额度照常工作。
 
+import { rollInvite } from "../store.mjs"
+
 export function makeCheckin(c) {
   return async (getAuth) => {
     const auth = await getAuth()
     if (!auth) return { outcome: "failed", message: "未登录" }
     try {
+      // 每天顺带把邀请码滚一次。
+      // 登录那一路虽然已经改成 await，但万一 host 进程在中途被回收，
+      // 滚动仍会丢；挂在这里（magpie 保证每天跑一次）可以第二天补上。
+      // rollInvite 内部自带超时和 try/catch，失败不影响签到。
+      await rollInvite(c.id, auth.jwt, auth.org, c.host)
       const { runCheckin } = await import("../tasks.mjs")
       return await runCheckin({ ...auth, host: c.host })
     } catch (e) {

package/src/hooks/methods.mjs

@@ -1,191 +1,243 @@
-// ② auth.methods[] —— 登录
-//
-// 两条路，按可靠性排：
-//
-//   ① 浏览器登录（默认，零输入）：插件自己拉起一个能被 CDP 看进去的浏览器，
-//      用户在官方页里用任何方式登，登录成功那一刻插件把 localStorage 读走。
-//      拉不起来就降级成「magpie 开系统浏览器 + 用户粘一行 Console」。
-//   ② 登录态（JWT + 组织码）：手填两个字段，兜底用。
-//
-// ⚠ 两条铁律：
-//   · authorize() 必须立刻返回 —— 真正等用户的是 callback()，死等会和 magpie 互锁
-//   · opened: true 的语义是「我自己已经开过页面了，你别再开」；
-//     只返回 url 让它去开的，**不许**传 opened
-
-import {
-  issueGatewayKey,
-  fetchPoints,
-  fetchWho,
-  fetchOwnInviteCode,
-} from "../api.mjs"
-import { inviteToUse, readSession, writeSession, noteLoginFailure, rollInvite } from "../store.mjs"
-import { CLIP_HINT, clipboardText, parseCreds, pollClipboard } from "../clipboard.mjs"
-
-export function makeMethods(c) {
-  return [
-    {
-      type: "oauth",
-      label: `${c.SHORT} 浏览器登录`,
-      async authorize() {
-        // 邀请码两条路都要出现：登录页的 URL，以及最终注册时服务端读到的那份
-        const inviteCode = inviteToUse(c.id)
-        const url = inviteCode
-          ? `${c.web}/login?invitation=${encodeURIComponent(inviteCode)}`
-          : `${c.web}/login`
-        const hostFragment = new URL(c.web).hostname
-
-        // 浏览器登录是**可选能力**，按需加载：这个模块用 child_process /
-        // WebSocket / 端口探测，环境依赖最重。静态 import 一旦失败，
-        // 整个插件都加载不起来 —— 连「登录态」那条备选也没了。
-        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)
-        }
-
-        // ⚠ 启动失败的原因必须留下 —— 静默降级会让用户以为「本机没装 Chrome」
-        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
-
-        // 降级通道要用的「打开前剪贴板」（不 await：起 powershell 要几百毫秒）
-        const skipPromise = session ? null : clipboardText()
-
-        return {
-          url,
-          ...(session ? { opened: true } : {}),
-          instructions: session
-            ? "浏览器已打开官方登录页 —— 用你平时的方式登进去，这个窗口会自动继续，不用回来点任何东西。"
-            : `没能自己拉起浏览器${why ? `（${why}）` : "（本机没找到 Chrome / Edge）"}，已改用系统浏览器打开登录页。\n登录完成后，在页面里按 F12 → Console 粘这一行：\n${CLIP_HINT}`,
-          method: "auto",
-          async callback() {
-            let got = null
-
-            // ① 首选：从我们自己拉起来的浏览器里读
-            if (session && browser) {
-              got = await browser.waitForCreds(session, hostFragment).catch(() => null)
-              // 拿到就关窗：先 Browser.close 让它把 cookie 刷到磁盘，
-              // 关不掉再 taskkill 整棵进程树
-              await browser.closeSession(session).catch(() => {})
-            }
-
-            // ② 降级：读剪贴板
-            if (!got && skipPromise) {
-              const skip = (await skipPromise).trim()
-              got = await pollClipboard({ skip })
-            }
-
-            if (!got) {
-              return {
-                type: "failed",
-                error: session
-                  ? "浏览器开着了，但 5 分钟内没在里面读到登录状态 —— 是还没登完，还是登的不是这个站点？"
-                  : "5 分钟内没拿到登录状态。可以改用「登录态（JWT + 组织码）」那条备选。",
-              }
-            }
-
-            try {
-              if (!got.org) throw new Error("只拿到 JWT，没有组织码")
-              // 真的验一次：读积分能过，说明 JWT + 组织码都对
-              await fetchPoints(got.jwt, got.org, c.host)
-              const key = await issueGatewayKey(got.jwt, got.org, c.host)
-              writeSession(c.id, got.jwt, got.org)
-              // 滚邀请码：把这个账号自己的码存成下一次用的
-              rollInvite(c.id, got.jwt, got.org, c.host).catch(() => {})
-              return {
-                type: "success",
-                access: key.apiKey,
-                refresh: key.refreshToken,
-                expires: Date.now() + 2 * 3600_000,
-                // 卡片显示能认的名字（手机号 / 邮箱 / 昵称），不是随机组织码
-                accountId: got.name || got.org,
-                uid: got.org,
-                jwt: got.jwt,
-                org: got.org,
-              }
-            } catch (e) {
-              return { type: "failed", error: String(e?.message ?? e) }
-            }
-          },
-        }
-      },
-    },
-    {
-      // 兜底：直接从浏览器复制登录态。
-      //
-      // 两样都在 DevTools → Application → Local Storage → <站点域名>：
-      //   MAGIC:user:authorization     → JSON，取 value   = JWT
-      //   MAGIC:user:organizationCode  → JSON，取 value   = 组织码
-      //
-      // ⚠ 组织码**不能从 JWT 推**：JWT 里只有 cus.tenant_id（18 位数字），
-      //   组织码是另一套短串。服务端按组织码查组织：
-      //   缺了 → {"code":2182,"message":"用户所在组织不存在"}
-      //   错了 → {"code":3035,"message":"登录失败"}
-      type: "oauth",
-      label: `${c.SHORT} 登录态（JWT + 组织码）`,
-      prompts: [
-        {
-          type: "text",
-          key: "jwt",
-          message: "JWT（MAGIC:user:authorization 的 value）",
-          placeholder: "eyJhbGciOi...",
-          validate: (v) => (String(v || "").trim().startsWith("eyJ") ? undefined : "不是 JWT，要以 eyJ 开头"),
-        },
-        {
-          type: "text",
-          key: "org",
-          message: "组织码（MAGIC:user:organizationCode 的 value）",
-          placeholder: "orgcode67890",
-          validate: (v) => (/^[a-z0-9]{6,32}$/i.test(String(v || "").trim()) ? undefined : "12 位左右的字母数字"),
-        },
-      ],
-      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: "没填组织码" }
-
-        const result = (async () => {
-          await fetchPoints(jwt, org, c.host)
-          return issueGatewayKey(jwt, org, c.host)
-        })()
-
-        return {
-          url: `${c.web}/login`,
-          instructions: "正在验证登录态…",
-          method: "auto",
-          opened: false,
-          async callback() {
-            let r
-            try {
-              r = await result
-            } catch (e) {
-              return { type: "failed", error: String(e?.message ?? e) }
-            }
-            writeSession(c.id, jwt, org)
-            rollInvite(c.id, jwt, org, c.host).catch(() => {})
-            // 卡片上显示手机号/邮箱/昵称，取不到就退回组织码
-            const who = await fetchWho(jwt, org, c.host).catch(() => null)
-            return {
-              type: "success",
-              access: r.apiKey,
-              refresh: r.refreshToken,
-              expires: Date.now() + 2 * 3600_000,
-              accountId: who?.name || org,
-              uid: org,
-              jwt,
-              org,
-            }
-          },
-        }
-      },
-    },
-  ]
-}
+// ② auth.methods[] —— 登录
+//
+// 两条路，按可靠性排：
+//
+//   ① 浏览器登录（默认，零输入）：插件自己拉起一个能被 CDP 看进去的浏览器，
+//      用户在官方页里用任何方式登，登录成功那一刻插件把 localStorage 读走。
+//      拉不起来就降级成「magpie 开系统浏览器 + 用户粘一行 Console」。
+//   ② 登录态（JWT + 组织码）：手填两个字段，兜底用。
+//
+// ⚠ 两条铁律：
+//   · authorize() 必须立刻返回 —— 真正等用户的是 callback()，死等会和 magpie 互锁
+//   · opened: true 的语义是「我自己已经开过页面了，你别再开」；
+//     只返回 url 让它去开的，**不许**传 opened
+
+import {
+  issueGatewayKey,
+  fetchPoints,
+  fetchWho,
+  fetchOwnInviteCode,
+} from "../api.mjs"
+import { inviteToUse, readSession, writeSession, noteLoginFailure, noteOrg, readKnownOrgs, rollInvite } from "../store.mjs"
+import { readLocalCreds } from "../local-browser.mjs"
+import { CLIP_HINT, clipboardText, parseCreds, pollClipboard } from "../clipboard.mjs"
+
+export function makeMethods(c) {
+  return [
+    {
+      type: "oauth",
+      label: `${c.SHORT} 浏览器登录`,
+      async authorize() {
+        // 邀请码两条路都要出现：登录页的 URL，以及最终注册时服务端读到的那份
+        const inviteCode = inviteToUse(c.id)
+        const url = inviteCode
+          ? `${c.web}/login?invitation=${encodeURIComponent(inviteCode)}`
+          : `${c.web}/login`
+        const hostFragment = new URL(c.web).hostname
+
+        // ⓿ 本机浏览器里已经有这个站点的登录态 → 直接接上，不开窗口。
+        //
+        //   这是「有的人网页登录了、插件里却没多出账号」的正解：用户平时那个浏览器
+        //   登录完，凭据就已经落在它的 localStorage 里了 —— 读文件就能拿到，
+        //   不用再让他在这个窗口里重登一次。
+        //
+        //   ⚠ 只在这个账号**还没加过**时自动接：否则用户点登录是想加新账号，
+        //     自动接上的会是同一个，magpie 侧（同 accountId + 同 uid）只会替换旧账号。
+        const local = readLocalCreds(hostFragment)
+        if (local && !readKnownOrgs(c.id).includes(local.org)) {
+          return {
+            url,
+            opened: true, // 凭据来自本机浏览器，我们没开页面 —— 别让 magpie 再开一个
+            instructions: `已从本机 ${local.browser} 读到 ${c.SHORT} 的登录态，正在验证…`,
+            method: "auto",
+            async callback() {
+              let r
+              try {
+                // 请求放在 callback 里：authorize 必须立刻返回，而且没被调用时不该打网络
+                await fetchPoints(local.jwt, local.org, c.host)
+                r = await issueGatewayKey(local.jwt, local.org, c.host)
+              } catch (e) {
+                // 本机那把失效了：记进「加过」名单，下次点登录就走窗口
+                noteOrg(c.id, local.org)
+                return {
+                  type: "failed",
+                  error: `本机 ${local.browser} 里的登录态已失效（${String(e?.message ?? e)}）。再点一次登录会打开窗口；或者先去那个浏览器里重新登录。`,
+                }
+              }
+              writeSession(c.id, local.jwt, local.org)
+              noteOrg(c.id, local.org)
+              // 等它落盘再返回：这条以前是 .catch(()=>{}) 发射后不管，
+              // 一旦 host 进程在 callback 之后被回收，滚动就永远不生效
+              await rollInvite(c.id, local.jwt, local.org, c.host)
+              const who = await fetchWho(local.jwt, local.org, c.host).catch(() => null)
+              return {
+                type: "success",
+                access: r.apiKey,
+                refresh: r.refreshToken,
+                expires: Date.now() + 2 * 3600_000,
+                accountId: who?.name || local.org,
+                uid: local.org,
+                jwt: local.jwt,
+                org: local.org,
+              }
+            },
+          }
+        }
+
+        // 浏览器登录是**可选能力**，按需加载：这个模块用 child_process /
+        // WebSocket / 端口探测，环境依赖最重。静态 import 一旦失败，
+        // 整个插件都加载不起来 —— 连「登录态」那条备选也没了。
+        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)
+        }
+
+        // ⚠ 启动失败的原因必须留下 —— 静默降级会让用户以为「本机没装 Chrome」
+        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
+
+        // 降级通道要用的「打开前剪贴板」（不 await：起 powershell 要几百毫秒）
+        const skipPromise = session ? null : clipboardText()
+
+        return {
+          url,
+          ...(session ? { opened: true } : {}),
+          instructions: session
+            ? "浏览器已打开官方登录页 —— 用你平时的方式登进去，这个窗口会自动继续，不用回来点任何东西。"
+            : `没能自己拉起浏览器${why ? `（${why}）` : "（本机没找到 Chrome / Edge）"}，已改用系统浏览器打开登录页。\n登录完成后，在页面里按 F12 → Console 粘这一行：\n${CLIP_HINT}`,
+          method: "auto",
+          async callback() {
+            let got = null
+
+            // ① 首选：从我们自己拉起来的浏览器里读
+            if (session && browser) {
+              got = await browser.waitForCreds(session, hostFragment).catch(() => null)
+              // 拿到就关窗：先 Browser.close 让它把 cookie 刷到磁盘，
+              // 关不掉再 taskkill 整棵进程树
+              await browser.closeSession(session).catch(() => {})
+            }
+
+            // ② 降级：读剪贴板
+            if (!got && skipPromise) {
+              const skip = (await skipPromise).trim()
+              got = await pollClipboard({ skip })
+            }
+
+            if (!got) {
+              return {
+                type: "failed",
+                error: session
+                  ? "浏览器开着了，但 5 分钟内没在里面读到登录状态 —— 是还没登完，还是登的不是这个站点？"
+                  : "5 分钟内没拿到登录状态。可以改用「登录态（JWT + 组织码）」那条备选。",
+              }
+            }
+
+            try {
+              if (!got.org) throw new Error("只拿到 JWT，没有组织码")
+              // 真的验一次：读积分能过，说明 JWT + 组织码都对
+              await fetchPoints(got.jwt, got.org, c.host)
+              const key = await issueGatewayKey(got.jwt, got.org, c.host)
+              writeSession(c.id, got.jwt, got.org)
+              noteOrg(c.id, got.org)
+              // 滚邀请码：把这个账号自己的码存成下一次用的（等落盘再返回）
+              await rollInvite(c.id, got.jwt, got.org, c.host)
+              return {
+                type: "success",
+                access: key.apiKey,
+                refresh: key.refreshToken,
+                expires: Date.now() + 2 * 3600_000,
+                // 卡片显示能认的名字（手机号 / 邮箱 / 昵称），不是随机组织码
+                accountId: got.name || got.org,
+                uid: got.org,
+                jwt: got.jwt,
+                org: got.org,
+              }
+            } catch (e) {
+              return { type: "failed", error: String(e?.message ?? e) }
+            }
+          },
+        }
+      },
+    },
+    {
+      // 兜底：直接从浏览器复制登录态。
+      //
+      // 两样都在 DevTools → Application → Local Storage → <站点域名>：
+      //   MAGIC:user:authorization     → JSON，取 value   = JWT
+      //   MAGIC:user:organizationCode  → JSON，取 value   = 组织码
+      //
+      // ⚠ 组织码**不能从 JWT 推**：JWT 里只有 cus.tenant_id（18 位数字），
+      //   组织码是另一套短串。服务端按组织码查组织：
+      //   缺了 → {"code":2182,"message":"用户所在组织不存在"}
+      //   错了 → {"code":3035,"message":"登录失败"}
+      type: "oauth",
+      label: `${c.SHORT} 登录态（JWT + 组织码）`,
+      prompts: [
+        {
+          type: "text",
+          key: "jwt",
+          message: "JWT（MAGIC:user:authorization 的 value）",
+          placeholder: "eyJhbGciOi...",
+          validate: (v) => (String(v || "").trim().startsWith("eyJ") ? undefined : "不是 JWT，要以 eyJ 开头"),
+        },
+        {
+          type: "text",
+          key: "org",
+          message: "组织码（MAGIC:user:organizationCode 的 value）",
+          placeholder: "orgcode67890",
+          validate: (v) => (/^[a-z0-9]{6,32}$/i.test(String(v || "").trim()) ? undefined : "12 位左右的字母数字"),
+        },
+      ],
+      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: "没填组织码" }
+
+        const result = (async () => {
+          await fetchPoints(jwt, org, c.host)
+          return issueGatewayKey(jwt, org, c.host)
+        })()
+
+        return {
+          url: `${c.web}/login`,
+          instructions: "正在验证登录态…",
+          method: "auto",
+          opened: false,
+          async callback() {
+            let r
+            try {
+              r = await result
+            } catch (e) {
+              return { type: "failed", error: String(e?.message ?? e) }
+            }
+            writeSession(c.id, jwt, org)
+            noteOrg(c.id, org)
+            await rollInvite(c.id, jwt, org, c.host)
+            // 卡片上显示手机号/邮箱/昵称，取不到就退回组织码
+            const who = await fetchWho(jwt, org, c.host).catch(() => null)
+            return {
+              type: "success",
+              access: r.apiKey,
+              refresh: r.refreshToken,
+              expires: Date.now() + 2 * 3600_000,
+              accountId: who?.name || org,
+              uid: org,
+              jwt,
+              org,
+            }
+          },
+        }
+      },
+    },
+  ]
+}

package/src/keys.mjs

@@ -2,10 +2,21 @@
 //
 //   登录成功  → issueAndStore()  签一把放进「另一个槽」，切过去
 //   loader    → ensureKey()      快过期就把新的签到另一个槽，切过去；旧的留着当回退
-//   refresh   → ensureKey()      同上，magpie 拿到的也是同一把
+//   refresh   → ⚠ **不经过本模块**。src/hooks/refresh.mjs 自己调
+//               api.refreshGatewayKey(auth.refresh)，magpie 拿到的不是这一把。
 //
 // **每个账号一套槽，互不干扰** —— 同站点登两个账号时，第二个人登录不会碰第一个人的 key。
 // 账号标识用 `org`（组织码），拿不到才退回 accountId。
+//
+// ⚠ 上面那条 refresh 是「唯一出口」这个设计里**唯一没落地的口子**（2026-10-27 核对）：
+//   refresh_token 是一次性轮换的，两条路径各用各的那份会分叉 ——
+//   ensureKey 轮换后 store 里是新值，refresh.mjs 手里 magpie 的还是旧值，
+//   再调就是 401 → magpie 判定「登录已失效」→ 让用户重新登录。
+//
+//   目前不会触发，因为 **store 从来没被写过**（本机 magicrew-key-*.json 一个都没有，
+//   说明 ensureKey 从没执行过 —— 没发过模型请求）。但这意味着：
+//   **若将来要给 checkin 补 ensureKey，必须先把这个钩子也收敛进来**，
+//   否则就是亲手把「一条路」掰成两条，用「多写一句文档」换「用户莫名掉登录」。
 
 import { issueGatewayKey, refreshGatewayKey } from "./api.mjs"
 import {

package/src/local-browser.mjs

@@ -0,0 +1,163 @@
+// 从**本机浏览器的 localStorage** 里读 magicrew 登录态 —— 不开窗口、不让用户粘任何东西。
+//
+// ═══ 为什么需要这条路 ═══════════════════════════════════════════════
+//
+// magicrew 没有 OAuth 回调通道（见 docs/internals.md 第九节），所以「用户在网页上
+// 登录成功」这件事，插件原本只能靠「自己起的那个浏览器」知道。于是有一个反复被报的
+// 现象：**用户在自己浏览器里登好了，插件里却没有多出账号** —— 因为那是另一个浏览器。
+//
+// 但凭据其实就躺在本地：Chromium 系（Edge / Chrome / Brave）把 localStorage 明文写在
+//
+//     <User Data>/<Default|Profile N>/Local Storage/leveldb/*.log|*.ldb
+//
+// 里，key 是 `_<origin>\x00\x01<name>`，值是 JSON。直接读文件就行，不用 CDP、不用开窗口。
+//
+// 读法：把 leveldb 目录按 latin1 拼成文本 → 以站点 host 出现的位置开一个窗口 →
+// 在同一个窗口里找 `"key":"authorization"` 与 `"key":"organizationCode2?"`。
+// LevelDB 按 key 排序，同一 origin 的记录挨在一起，所以窗口内配对是可靠的
+// （实测本机 Edge：`www.letsmagic.cn` 命中、`www.magicrew.ai` 不命中，不会串）。
+//
+// 成本：本机 Edge 27 MB / 34 ms。全部浏览器扫一遍通常 < 300 ms。
+//
+// ⚠ 只读。不写文件、不改浏览器数据、不碰 cookie。
+
+import { homedir } from "node:os"
+import { readdirSync, readFileSync } from "node:fs"
+import { join } from "node:path"
+
+/** 同一个 origin 的若干条记录（theme / i18n / userInfo / authorization …）挤在一起，
+ *  2000 字节足够覆盖到 organizationCode；太小会漏、太大可能跨到另一个站点 */
+const WINDOW = 2000
+
+/** 各平台的浏览器 User Data 根目录；不存在就跳过 */
+function roots() {
+  const h = homedir()
+  if (process.platform === "win32") {
+    const local = process.env.LOCALAPPDATA || join(h, "AppData", "Local")
+    return [
+      ["Edge", join(local, "Microsoft", "Edge", "User Data")],
+      ["Chrome", join(local, "Google", "Chrome", "User Data")],
+      ["Brave", join(local, "BraveSoftware", "Brave-Browser", "User Data")],
+      ["Chromium", join(local, "Chromium", "User Data")],
+    ]
+  }
+  if (process.platform === "darwin") {
+    return [
+      ["Chrome", join(h, "Library/Application Support/Google/Chrome")],
+      ["Edge", join(h, "Library/Application Support/Microsoft Edge")],
+      ["Brave", join(h, "Library/Application Support/BraveSoftware/Brave-Browser")],
+      ["Chromium", join(h, "Library/Application Support/Chromium")],
+    ]
+  }
+  return [
+    ["Chrome", join(h, ".config/google-chrome")],
+    ["Chromium", join(h, ".config/chromium")],
+    ["Edge", join(h, ".config/microsoft-edge")],
+    ["Brave", join(h, ".config/BraveSoftware/Brave-Browser")],
+  ]
+}
+
+function profilesOf(root) {
+  try {
+    return readdirSync(root).filter((n) => n === "Default" || /^Profile \d+$/.test(n))
+  } catch {
+    return []
+  }
+}
+
+function leveldbText(root, profile) {
+  const dir = join(root, profile, "Local Storage", "leveldb")
+  let files
+  try {
+    files = readdirSync(dir)
+  } catch {
+    return ""
+  }
+  let text = ""
+  for (const f of files) {
+    try {
+      text += readFileSync(join(dir, f)).toString("latin1")
+    } catch {}
+  }
+  return text
+}
+
+/** jwt 里的 iat / exp；解不出来返回 0 */
+function jwtTimes(jwt) {
+  try {
+    const body = JSON.parse(Buffer.from(String(jwt).split(".")[1] || "", "base64url").toString("utf8"))
+    return { iat: Number(body.iat) || 0, exp: Number(body.exp) || 0 }
+  } catch {
+    return { iat: 0, exp: 0 }
+  }
+}
+
+/** LevelDB 里一条记录的前缀：`_https://<origin>\x00\x01<name>` */
+const ORIGIN_RE = /_https?:\/\/([^\x00\x01"\\]{4,80})\x00\x01/g
+
+/**
+ * 在 host 每一次出现的位置开窗，取窗口内同一 origin 的 jwt × org 组合。
+ *
+ * ⚠ 必须按 origin 截断：两个站点的记录可能相邻（用户两个都登录过），
+ *   2000 字节的窗口会把国际站的 org 配到国内站的 jwt 上。
+ *   截断点 = 「下一个**不同站点**的 origin」，同站点的多条记录不截断。
+ */
+function credsNear(text, host, win = WINDOW) {
+  const bare = host.replace(/^www\./, "")
+  const origins = []
+  for (const m of text.matchAll(ORIGIN_RE)) origins.push({ host: m[1], at: m.index })
+
+  const out = []
+  let at = -1
+  while ((at = text.indexOf(host, at + 1)) !== -1) {
+    let stop = Math.min(text.length, at + win)
+    for (const o of origins) {
+      if (o.at > at && !o.host.includes(bare)) {
+        stop = o.at
+        break
+      }
+    }
+    const w = text.slice(at, stop)
+    // 每把 jwt 配**它自己后面**最近的那个组织码：
+    // LevelDB 按 key 排序（authorization < organizationCode），同一批写入的挨在一起；
+    // 取「窗口内第一个 org」会在同一站点存过多把凭据时配错。
+    for (const m of w.matchAll(/"key":"authorization","value":"(eyJ[^"]+)"/g)) {
+      const tail = w.slice(m.index)
+      const org = (tail.match(/"key":"organizationCode2?","value":"([^"]+)"/) || [])[1]
+      if (org) out.push({ jwt: m[1], org })
+    }
+  }
+  return out
+}
+
+/**
+ * 读本机浏览器里属于这个站点的登录态。
+ *
+ * @param {string} hostname 例如 `www.letsmagic.cn`
+ * @returns {{jwt:string, org:string, browser:string, profile:string, host:string, iat:number} | null}
+ *          取 iat 最新、且未过期的那一把；读不到返回 null（调用方降级到窗口登录）。
+ */
+export function readLocalCreds(hostname, { now = Date.now() } = {}) {
+  const bare = String(hostname || "").trim().replace(/^www\./, "")
+  if (!bare) return null
+  const hosts = [hostname, bare, `www.${bare}`].filter((v, i, a) => v && a.indexOf(v) === i)
+
+  let best = null
+  for (const [browser, root] of roots()) {
+    for (const profile of profilesOf(root)) {
+      const text = leveldbText(root, profile)
+      if (!text) continue
+      for (const host of hosts) {
+        for (const c of credsNear(text, host)) {
+          const { iat, exp } = jwtTimes(c.jwt)
+          if (!iat) continue
+          if (exp && exp * 1000 < now) continue
+          if (!best || iat > best.iat) best = { ...c, iat, browser, profile, host }
+        }
+      }
+    }
+  }
+  return best
+}
+
+export const _internal = { roots, profilesOf, leveldbText, credsNear, jwtTimes, WINDOW }