magicrew-auth 0.3.5 → 0.3.7

package/docs/npm-publish.md

@@ -0,0 +1,77 @@
+# 发 npm：`magicrew-auth`
+
+> 线上：https://www.npmjs.com/package/magicrew-auth
+> 首次发布 2026-10-27，`0.3.5`。**这个包名已经是我们的，之后只增版本，不再改名。**
+
+## 一条命令
+
+```bash
+npm run publish:npm                 # 真发
+npm run publish:npm -- --dry-run    # 预演，看包名与打包面，不上传
+```
+
+脚本是 `publish-npm.mjs`，做的事只有一件：**发布那一下把 `name` 换成 `magicrew-auth`，跑完还原。**
+
+## 为什么必须换名
+
+registry 拒绝含大写字母的**新**包名，而 `package.json` 的 `name` 要同时喂两个地方：
+
+| 谁读 | 读哪份 | 决定什么 |
+|---|---|---|
+| `bun`（`magpie plugin add github:…`） | 仓库里的 `package.json` | 依赖键 → **卡片标题 `Magicrew`** |
+| `npm publish` | 同一份 | npm 上的**包名** → 必须小写 `magicrew-auth` |
+
+所以 npm 装的卡片标题是 `magicrew-auth`，git 装的卡片标题是 `Magicrew` —— 功能一样，只是标题。
+FAQ 里对用户写过这条，别把它当 bug 修。
+
+还原是硬要求：脚本在 `finally` 之外还挂了 `exit` / `SIGINT` 钩子。实测跑完
+`sha256sum package.json` 与跑前逐字节一致。
+
+## 发之前的三条
+
+1. **bump `version`** —— 同版本号 publish 会被 registry 拒。
+2. **`npm view magicrew-auth version` 看现在线上的版本**，别发重复。
+3. README 会随包发出去，成为 magpie 卡片正文 —— **npm 用户的卡片只有发版才更新**
+   （git 源用户 push 即见）。所以 README 改完要跟着一个版本走。
+
+## 发完之后会看到 `0.0.0-stage`，别慌
+
+registry 上会先多出一个占位版本：
+
+```json
+{ "version": "0.0.0-stage", "stub": true,
+  "description": "Temporary package placeholder for staged publishing" }
+```
+
+`dist-tags.latest` 可能先指向它，几秒后指向真版本；`npm stage list` 显示「没有 staged 版本」。
+判据：
+
+```bash
+curl -s https://registry.npmjs.org/magicrew-auth | python -c "import json,sys;d=json.load(sys.stdin);print(d['dist-tags'])"
+# {'latest': '0.3.5'}
+curl -s -o /dev/null -w '%{http_code}\n' https://registry.npmjs.org/magicrew-auth/0.3.5
+# 200
+```
+
+## 验收（2026-10-27 实测）
+
+```
+npm view magicrew-auth version     → 0.3.5
+npm view magicrew-auth dist-tags   → { latest: '0.3.5' }
+npm i magicrew-auth && node -e "import('magicrew-auth')"
+  → exports: MagicrewAuthPlugin, MagicrewIntlAuthPlugin, SITES, _internal
+tarball 26 files / 118.5 kB，README 是当期版本
+```
+
+## ⚠ npm 搜索搜不到，不等于包有问题
+
+magpie 的发现搜索是 `/-/v1/search?text=<query> opencode`。实测：
+
+| 查询 | 结果 |
+|---|---|
+| `text=magicrew` | total 1，命中 |
+| `text=magicrew opencode` | total 18500，**前 250 条里没有它** |
+| `text=letsmagic` | total 1，命中 |
+
+零下载的新包在混合查询里会被 opencode 生态的高下载包淹没。**能保证被发现的路径是 GitHub topic**
+（仓库已带 `magpie-plugin` / `magpie` / `opencode` → Discover → Unofficial）。搜索排名随下载量积累会好转。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "magicrew-auth",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "description": "超级麦吉 / MagiCrew for magpie and OpenCode — one package, two providers: letsmagic.cn (国内) and magicrew.ai (international). Password or web-JWT sign-in, the account's own live model list, points balance, newcomer rewards, invite codes.",
   "type": "module",
   "main": "./index.mjs",

package/src/browser-login.mjs

@@ -13,22 +13,69 @@
 // 页面是我们自己开的，告诉 magpie 「别再开一次」。
 //
 // ⚠ 独立 profile 意味着用户要在这个窗口里登一次（没有他日常浏览器的 cookie）。
-//   所以 profile 目录**不删**，下次还能复用登录态：~/.cache/magpie/magicrew-login-profile
+//   **每次登录一个一次性 profile，用完删** —— 为什么不能复用，见下面 newProfileDir()。
 
 import { spawn } from "node:child_process"
-import { existsSync, readFileSync, mkdirSync } from "node:fs"
+import { existsSync, readFileSync, mkdirSync, readdirSync, rmSync, statSync } from "node:fs"
 import { homedir } from "node:os"
 import { join } from "node:path"
 
-/** 复用同一个 profile：第二次登录时里面已经有 cookie 了 */
-function profileDir() {
-  const d = join(homedir(), ".cache", "magpie", "magicrew-login-profile")
-  try {
-    mkdirSync(d, { recursive: true })
-  } catch {}
+const BASE = () => join(homedir(), ".cache", "magpie")
+
+/**
+ * 每次登录一个**一次性** profile 目录，登录结束就删。
+ *
+ * ⚠ 这里曾经刻意复用同一个目录（旧注释：`复用同一个 profile：第二次登录时里面已经有 cookie 了`），
+ *   那是个 bug —— 现象是「添加第二个账号时，网页正确弹出、然后瞬间关闭，
+ *   magpie 里也没多出账号」：
+ *
+ *     ① 复用目录里的 localStorage 还躺着**上一个账号**的 jwt + org；
+ *     ② 浏览器一打开，`waitForCreds` 第一轮（1.5 秒内）就读到它 → 判定「登录完成」→ 关窗；
+ *     ③ magpie 拿到的 accountId / uid 与已有账号一模一样，按契约
+ *        （同一 accountId + 同一 uid → 替换旧账号）不会新增账号。
+ *
+ *   一次性目录把这条路彻底堵死：读到的凭据只可能是本次登录写进去的。
+ *   代价是每次都要在这个窗口里重新登一次 —— 独立 profile 本来也没有他日常浏览器的 cookie。
+ */
+export function newProfileDir() {
+  const d = join(
+    BASE(),
+    `magicrew-login-${process.pid}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`,
+  )
+  mkdirSync(d, { recursive: true })
   return d
 }
 
+/**
+ * 清残留：超过 maxAgeMs 的一次性 profile，以及历史上那个**复用**目录
+ * （`magicrew-login-profile`，里面装着别的账号的 cookie —— 正是上面那个 bug 的来源）。
+ * 只删本插件自己造的名字，别的一概不碰。
+ */
+export function sweepProfiles({ maxAgeMs = 2 * 3600_000 } = {}) {
+  let names = []
+  try {
+    names = readdirSync(BASE())
+  } catch {
+    return 0
+  }
+  let removed = 0
+  for (const name of names) {
+    const legacy = name === "magicrew-login-profile"
+    if (!legacy && !/^magicrew-login-/.test(name)) continue
+    const p = join(BASE(), name)
+    try {
+      // ⚠ 只动目录：同前缀的日志文件（magicrew-login-*.log）不是 profile
+      const st = statSync(p)
+      if (!st.isDirectory()) continue
+      // 遗留的复用目录不管多新都删；一次性目录只在过期后删（可能正有别的账号在登）
+      if (!legacy && Date.now() - st.mtimeMs < maxAgeMs) continue
+      rmSync(p, { recursive: true, force: true, maxRetries: 3, retryDelay: 200 })
+      removed++
+    } catch {}
+  }
+  return removed
+}
+
 /** 按平台找浏览器；找不到返回 null，调用方降级 */
 export function findBrowser() {
   const plat = process.platform
@@ -91,8 +138,11 @@ export async function launchLoginBrowser(url) {
   const exe = findBrowser()
   if (!exe) throw new Error("本机没找到 Chrome / Edge / Bravo / Chromium")
 
-  const dir = profileDir()
-  // ⚠ 上一次的残留会让这次「看起来起来了、其实什么都没做」：
+  // 先扫掉上一次登录留下的临时 profile（含历史复用目录），再开一个全新的
+  sweepProfiles()
+  const dir = newProfileDir()
+  // ⚠ 残留会让这次「看起来起来了、其实什么都没做」—— 一次性目录里通常没有，
+  //   但 sweep 失败、或目录被复用时它们就是根因，清一遍几乎不花钱：
   //   DevToolsActivePort  —— 不清掉，waitPort 会立刻返回一个已失效的旧端口
   //   SingletonLock / SingletonCookie / SingletonSocket / lockfile
   //                       —— 不清掉，新进程判定 profile 被占用，把 URL 转交给
@@ -128,6 +178,9 @@ export async function launchLoginBrowser(url) {
     try {
       child.kill()
     } catch {}
+    try {
+      rmSync(dir, { recursive: true, force: true, maxRetries: 2, retryDelay: 150 })
+    } catch {}
     throw new Error("浏览器进程起来了，但 8 秒内没写出调试端口 DevToolsActivePort（多半是 profile 被一个已退出的实例占着）")
   }
   return { port, dir, child }
@@ -229,16 +282,31 @@ const READ_CREDS = `(() => {
 
 /**
  * 盯着那个浏览器，直到页面里的 localStorage 出现完整凭据。
- * @returns {Promise<{jwt:string, org:string} | null>}
+ *
+ * `baseline` = 「窗口打开时就已经在 localStorage 里的那份」。传进来的话，
+ * 只有**跟它不一样**的凭据才算登录成功。一次性 profile 下它恒为空，
+ * 留着是第二道防线：万一哪天又改回复用目录，这条判据能挡住「读到上一个账号」。
+ *
+ * @param {{jwt:string, org:string}|null} [opts.baseline]
+ * @param {(port:number, host:string, expr:string)=>Promise<string>} [opts.probe] 测试注入用
+ * @returns {Promise<{jwt:string, org:string, name?:string} | null>}
  */
-export async function waitForCreds(session, hostFragment, { timeout = 300_000, interval = 1500 } = {}) {
+export async function waitForCreds(
+  session,
+  hostFragment,
+  { timeout = 300_000, interval = 1500, baseline = null, probe = evaluate } = {},
+) {
+  const base = baseline ?? session?.baseline ?? null
   const deadline = Date.now() + timeout
   while (Date.now() < deadline) {
     try {
-      const raw = await evaluate(session.port, hostFragment, READ_CREDS)
+      const raw = await probe(session.port, hostFragment, READ_CREDS)
       if (raw) {
         const o = JSON.parse(raw)
-        if (o?.jwt?.startsWith("eyJ") && o?.org) return o
+        if (o?.jwt?.startsWith("eyJ") && o?.org) {
+          const same = base && o.jwt === base.jwt && o.org === base.org
+          if (!same) return o
+        }
       }
     } catch {
       // 页面还在加载 / target 换了 —— 下一轮再试
@@ -249,13 +317,17 @@ export async function waitForCreds(session, hostFragment, { timeout = 300_000, i
 }
 
 /**
- * 关掉这个浏览器窗口。profile 留着，下次复用登录态。
+ * 关掉这个浏览器窗口，然后把这一次的临时 profile 删掉。
  *
  * 两条路都要走：
- *   ① CDP 的 `Browser.close` —— 走浏览器自己的退出流程，cookie 会被刷到磁盘
- *      （profile 里没有落盘的 cookie，下次登录还得再来一次）
+ *   ① CDP 的 `Browser.close` —— 走浏览器自己的退出流程，进程干净退出
  *   ② 兜底 kill —— ①在 2 秒内没关掉就强杀整棵进程树
- *      （Windows 上 kill() 只杀主进程，渲染/GPU 子进程会留着占住 profile）
+ *      （Windows 上 kill() 只杀主进程，渲染/GPU 子进程会留着占住 profile，
+ *        后面的 rmSync 也会因为文件锁失败）
+ *
+ * ⚠ profile 是**一次性**的，删掉是对的：里面只有这次登录的 cookie，
+ *   留着只会让下一次登录读到上一个账号（见 newProfileDir 的注释）。
+ *   删不掉不影响正确性 —— 下次 launch 会先 sweepProfiles()。
  */
 export async function closeSession(session) {
   if (!session) return
@@ -302,21 +374,35 @@ export async function closeSession(session) {
 
   // ② 兜底：还活着就强杀整棵进程树
   const pid = session.child?.pid
-  if (!pid) return
-  try {
-    if (process.platform === "win32") {
-      await new Promise((resolve) => {
-        const k = spawn("taskkill", ["/PID", String(pid), "/T", "/F"], { stdio: "ignore", windowsHide: true })
-        k.on("exit", resolve)
-        k.on("error", resolve)
-        setTimeout(resolve, 3000)
-      })
-    } else {
-      try {
-        session.child.kill("SIGKILL")
-      } catch {}
+  if (pid) {
+    try {
+      if (process.platform === "win32") {
+        await new Promise((resolve) => {
+          const k = spawn("taskkill", ["/PID", String(pid), "/T", "/F"], { stdio: "ignore", windowsHide: true })
+          k.on("exit", resolve)
+          k.on("error", resolve)
+          setTimeout(resolve, 3000)
+        })
+      } else {
+        try {
+          session.child.kill("SIGKILL")
+        } catch {}
+      }
+    } catch {}
+  }
+
+  // ③ 删掉这一次的临时 profile。文件锁通常要等子进程死透才放，
+  //    所以给它几次机会；删不掉就算了，下次 launch 会 sweep。
+  const dir = session.dir
+  if (!dir) return
+  for (let i = 0; i < 5; i++) {
+    try {
+      rmSync(dir, { recursive: true, force: true, maxRetries: 2, retryDelay: 150 })
+      return
+    } catch {
+      await new Promise((r) => setTimeout(r, 200))
     }
-  } catch {}
+  }
 }
 
-export const _internal = { READ_CREDS, profileDir, waitPort, evaluate }
+export const _internal = { READ_CREDS, newProfileDir, sweepProfiles, waitPort, evaluate }

package/src/hooks/methods.mjs

@@ -18,7 +18,8 @@ import {
   fetchWho,
   fetchOwnInviteCode,
 } from "../api.mjs"
-import { inviteToUse, readSession, writeSession, noteLoginFailure, rollInvite } from "../store.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) {
@@ -34,6 +35,53 @@ export function makeMethods(c) {
           : `${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)
+              rollInvite(c.id, local.jwt, local.org, c.host).catch(() => {})
+              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 一旦失败，
         // 整个插件都加载不起来 —— 连「登录态」那条备选也没了。
@@ -97,6 +145,7 @@ export function makeMethods(c) {
               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)
               // 滚邀请码：把这个账号自己的码存成下一次用的
               rollInvite(c.id, got.jwt, got.org, c.host).catch(() => {})
               return {
@@ -170,6 +219,7 @@ export function makeMethods(c) {
               return { type: "failed", error: String(e?.message ?? e) }
             }
             writeSession(c.id, jwt, org)
+            noteOrg(c.id, org)
             rollInvite(c.id, jwt, org, c.host).catch(() => {})
             // 卡片上显示手机号/邮箱/昵称，取不到就退回组织码
             const who = await fetchWho(jwt, org, c.host).catch(() => null)

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 }

package/src/store.mjs

@@ -163,6 +163,40 @@ function writeSession(siteId, jwt, org) {
   } catch {}
 }
 
+// ═══ 加过哪些账号（只记 org）═══════════════════════════════════════════
+//
+// 唯一的用途：决定「本机浏览器里读到的登录态要不要自动接上」。
+//
+// 用户点「登录」多数是想加**新**账号；如果本机浏览器里那把属于已经加过的账号，
+// 自动接上只会得到「同一个账号」（magpie 侧同 accountId+uid → 替换，不新增），
+// 看起来又像「登录了却没加账号」。所以已经在名单里的 org，一律改走窗口登录。
+//
+// 记不上也无所谓：最坏是自动接上一个重复账号，magpie 会替换它。
+
+function orgsPath(siteId) {
+  return join(cacheDir(), `magicrew-orgs-${siteId}.json`)
+}
+
+function readKnownOrgs(siteId) {
+  try {
+    const v = JSON.parse(readFileSync(orgsPath(siteId), "utf8"))
+    return Array.isArray(v) ? v.filter((x) => typeof x === "string" && x) : []
+  } catch {
+    return []
+  }
+}
+
+function noteOrg(siteId, org) {
+  if (!org || typeof org !== "string") return
+  try {
+    const list = readKnownOrgs(siteId)
+    if (list.includes(org)) return
+    list.push(org)
+    const f = orgsPath(siteId)
+    mkdirSync(dirname(f), { recursive: true })
+    writeFileSync(f, JSON.stringify(list.slice(-50)))
+  } catch {}
+}
 
 export {
   AUTHOR_INVITE,
@@ -172,7 +206,10 @@ export {
   inviteToUse,
   loginLogPath,
   noteLoginFailure,
+  noteOrg,
+  orgsPath,
   readInvite,
+  readKnownOrgs,
   readSession,
   readSnapshot,
   sessionPath,