opencode-kunrouter-auth 0.0.0-stage → 0.8.3

package/CHANGELOG.md

@@ -0,0 +1,92 @@
+# 更新日志
+
+本文件记录主要版本变化，格式参考 [Keep a Changelog](https://keepachangelog.com/zh-CN/1.1.0/)，版本号遵循 [语义化版本](https://semver.org/lang/zh-CN/)。
+
+## [0.8.3] - 2026-11-12
+
+### 修复
+- 订阅总额和日/周/月滚动窗口恢复为进度条展示；剩余额度仍写在说明文字里。
+
+## [0.8.2] - 2026-11-12
+
+### 修复
+- 签到奖励按站点的额度比例换算，与钱包余额使用相同单位。
+
+## [0.8.1] - 2026-11-11
+
+### 变更
+- 额度卡精简为套餐、日/周/月滚动额度、钱包三类。
+- 订阅行改为「剩余 / 总额」，滚动窗口改为「剩余 / 上限」，到期时间只显示日期。
+- 分组和非默认计费优先级并入顶部套餐名，不再单独占一行。
+
+### 移除
+- 去掉「账号」「说明」和旧版「本期配额」行，不再从对话响应解析 `usage.quota`。
+
+## [0.8.0] - 2026-11-11
+
+### 新增
+- 额度卡改为读取 `/api/subscription/self` 和 `/api/subscription/plans`，显示订阅套餐名称、总额、已用、剩余和到期时间。
+- 订阅内的日/周/月滚动窗口分别显示额度、已用、剩余、窗口时长和下一次释放时间。
+- 显示账号当前的计费优先级（优先订阅 / 优先钱包 / 仅订阅 / 仅钱包）。
+- 订阅额度允许钱包兜底时按 `aside` 展示，不影响 Magpie 继续路由。
+
+### 变更
+- `period_window` 选项改为控制订阅额度展示；关掉后仍保留钱包余额。
+- 服务端需要允许 Magpie 读取 `GET /api/subscription/self` 与 `GET /api/subscription/plans`。
+
+## [0.7.0] - 2026-11-07
+
+### 变更
+- 重新登录改为覆盖原来的账号，不再生成 `kunrouter#xxxxxx` 的第二条记录，换 Key 不用先登出。
+- 手动登录入口更名为「手动填写 / 更换访问令牌 + API 密钥」，并且只问这两项，不再额外要求重复粘贴一次 `sk-`。
+
+## [0.6.0] - 2026-11-07
+
+集中修复此前记录的 9 个 issue（#4–#12）。
+
+### 修复
+- 流式（SSE）响应现在也会解析 `usage.quota`，本期配额不再只对非流式请求生效。
+- 只填访问令牌、没有 `sk-` 密钥时，直接返回可读的 401 提示，不再把访问令牌发到 `/v1`。
+- 邀请码被禁用 / 过期 / 名额满时，自动隐藏注册入口，不再让用户点进去才看到报错。
+- 钱包窗口单位跟随站点币种（`custom_currency_symbol`），不再写死 USD。
+- `/api/status`、`/api/user/self`、`/api/user/checkin`、`/v1/models`、`/api/desktop/keys` 统一加 10 秒超时。
+- 直连域名网络层失败时回退一次主站 `/v1`，避免整站明明可用却全部超时。
+- 额度卡的分组改为读取 `/api/desktop/keys` 的实时分组，读不到才退回授权时快照并标注。
+
+### 安全
+- 浏览器授权地址校验收紧到 `/desktop/authorize`，不再放行信任域上的任意路径。
+
+### 变更
+- 邀请码支持 `KUNROUTER_INVITE_CODE` 覆盖，不用改代码发版。
+- 新增 `registration_entry` 开关，可一键隐藏注册入口。
+- 注册入口文案补充「仅新用户」和剩余名额。
+
+## [0.5.0] - 2026-11-07
+
+### 新增
+- 用户在本站控制台删除 Key 后，插件用访问令牌自动重签一把同名 Key 并写回 Magpie，无需重新授权。
+
+## [0.4.1] - 2026-11-07
+
+### 变更
+- 邀请入口文案统一为「鸡蛋」。
+
+## [0.4.0] - 2026-11-07
+
+### 新增
+- Magpie 专属邀请码注册入口，注册页自动填入邀请码。
+- 授权回调信任域名白名单（`wcnmb.si` / `wcnmb.fun` / `kuncode.120403.xyz` 及子域）。
+
+## [0.3.0] - 2026-11-07
+
+### 新增
+- 浏览器一键授权：PKCE + 随机 `state` + 本机 loopback 回调，一次性授权码换取访问令牌和 `sk-` 密钥。
+- 授权时可选模型分组，重新授权会轮换凭据。
+
+## [0.1.0] - 2026-11-06
+
+### 新增
+- 首个版本：KunRouter 供应商插件，支持 magpie / OpenCode。
+- 钱包余额窗口（`/api/user/self`）与本期配额窗口（对话响应）。
+- 双凭据处理：访问令牌读 `/api`，`sk-` 密钥请求 `/v1`。
+- 供应商选项框：`direct_api`（直连域名）、`period_window`（本期配额栏）。

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 KunRouter
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,86 @@
-# Temporary Holding Version
+# opencode-kunrouter-auth
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[KunRouter](https://wcnmb.si) 的 **Magpie 插件**（同时兼容 OpenCode）：浏览器一键授权、钱包与订阅额度、每日签到。
+
+> 维护者：[MY-Final](https://github.com/MY-Final) · 插件名：KunRouter · 适用：Magpie / OpenCode
+
+## 装
+
+```sh
+git clone https://github.com/MY-Final/opencode-kunrouter-auth.git
+magpie plugin add ./opencode-kunrouter-auth
+```
+
+或直接 `magpie plugin add https://github.com/MY-Final/opencode-kunrouter-auth`。
+
+## 登录
+
+- **浏览器授权（推荐）**：打开 KunRouter 授权页，登录、选分组、确认授权，浏览器自动跳回本机一次性回调。插件拿不到账号密码，用 PKCE + 随机 `state` + loopback 回调，令牌不进跳转 URL。
+- **没有账号**：登录页的「注册并领取鸡蛋」入口会打开注册页并自动填入活动邀请码。邀请码不可用（禁用 / 过期 / 名额满）时入口自动隐藏；换活动用环境变量 `KUNROUTER_INVITE_CODE` 覆盖，不用改代码发版。
+- **手动填写 / 更换访问令牌 + API 密钥**：授权服务不可用时的兜底，也是换 Key 的入口。访问令牌读余额和签到，`sk-` 密钥请求模型；只填访问令牌也能登录，但**不能调用模型**（会直接提示补一把 `sk-`）。
+
+访问令牌：后台「个人设置 → 安全设置」；API 密钥：后台「令牌」新建，`sk-` 开头。
+
+### 控制台删了 Key？
+
+下次请求 401 时插件会用访问令牌自动重签一把同名 Key 并写回 Magpie，不需要重新授权；访问令牌也失效才需要重登。
+
+### 想换一把 Key？
+
+插件页打开 KunRouter，点「重新登录」，选「手动填写 / 更换访问令牌 + API 密钥」，把两把钥匙粘贴进去即可。重新登录会覆盖原来那条记录，不会多出 `kunrouter#xxxxxx` 账号，也不用先登出。
+
+```sh
+magpie plugin login kunrouter
+```
+
+只想换 `sk-`、不想再填访问令牌：在控制台删掉旧 Key，下次请求 401 时插件会自动重签一把同名 Key 并写回 Magpie。
+
+## 选项
+
+| 选项 | 默认 | 干什么 |
+| --- | --- | --- |
+| `direct_api` | 开 | 模型请求走 `direct.wcnmb.fun`，绕开 Cloudflare 的 100 秒上限；关掉走 `wcnmb.si/v1` |
+| `period_window` | 开 | 显示订阅剩余额度和滚动窗口；关掉只看钱包 |
+| `registration_entry` | 开 | 登录页显示注册入口；邀请码不可用时自动隐藏，关掉完全不提注册 |
+
+改完选项要重载插件，`config` 里的供应商地址才会跟着变。
+
+## 显示什么
+
+- **钱包**：`/api/user/self` 的 `quota`，按 `/api/status` 的 `quota_per_unit` 换算，单位跟随站点币种（本站 🥚）。
+- **订阅额度**：`/api/subscription/self` 里的套餐总额、已用、剩余和到期时间；Lite 等套餐的日/周/月滚动窗口也会分别显示为进度条。
+- **计费优先级**：非默认优先级会跟在顶部套餐名后，不再单独占一行。
+- **分组**：读 `/api/desktop/keys` 按 Key 遮罩匹配真实分组，读不到才退回授权时快照。
+- **签到**：站点开着 `checkin_enabled` 时每日自动签到。
+- **模型**：从 `/v1/models` 拉，拉不到退回内置占位模型。
+
+站点相关 `/api` 请求都有 10 秒超时，网络卡住不会把额度卡和签到一起拖死。
+
+## 域名
+
+- `https://wcnmb.si/api` —— 控制台和管理接口
+- `https://kuncode.120403.xyz/desktop/authorize` —— 浏览器授权页
+- `https://direct.wcnmb.fun/v1` —— 直连模型请求，绕开 Cloudflare 100 秒上限
+
+直连域名网络层挂了会自动回退一次主站 `wcnmb.si/v1`。授权地址只认 `wcnmb.si`、`wcnmb.fun`、`kuncode.120403.xyz` 及其子域下的 `/desktop/authorize`。
+
+## 本地联调
+
+```sh
+KUNROUTER_SITE=http://localhost:3000 \
+KUNROUTER_API=http://localhost:3000 \
+magpie plugin login kunrouter
+```
+
+后端 `ServerAddress` 要设成同一个 `http://localhost:3000`，否则授权回调会回正式域名；`magpie quota kunrouter` 也要带同样的环境变量。
+
+## 已知边界
+
+- 只有单一 provider id `kunrouter`，一台机器保留一个账号；重新登录会覆盖它。
+- 浏览器授权签发的凭据默认 30 天有效，重新授权会轮换两把凭据并按新分组重签。
+- 令牌失效时 `usage` 带 `signIn: "expired"`，magpie 会标出来让你重登。
+- 模型能力参数拿不到真实值，统一按 128k 上下文 / 8k 输出 / 支持工具调用填。
+
+## 更新日志
+
+见 [CHANGELOG.md](./CHANGELOG.md)。

package/index.mjs

@@ -0,0 +1,1064 @@
+// KunRouter (wcnmb.si) provider plugin for OpenCode / magpie.
+//
+// KunRouter 跑的是 new-api（one-api 的分支）。账号密码登录走浏览器授权，
+// 访问令牌留在 metadata，模型请求使用站点为该插件单独签发的 sk- 密钥。
+// 余额和签到走站点侧的 /api，模型请求走直连域名，绕开 Cloudflare 的 100 秒上限。
+
+import { createHash, randomBytes, timingSafeEqual } from "node:crypto"
+import { createServer } from "node:http"
+import { homedir, hostname } from "node:os"
+
+const PROVIDER = "kunrouter"
+const SITE =
+  process.env.KUNROUTER_SITE?.replace(/\/+$/, "") || "https://wcnmb.si" // 控制台 + /api
+const API =
+  process.env.KUNROUTER_API?.replace(/\/+$/, "") ||
+  "https://direct.wcnmb.fun" // 直连 /v1，不受 CF 超时限制
+const VERSION = "0.8.3"
+const MAGPIE_CLIENT_ID = "magpie"
+// 活动邀请码。改活动时优先用环境变量覆盖，不用改代码发版。
+const INVITE_CODE = (
+  process.env.KUNROUTER_INVITE_CODE ?? "shjglbwadfbhblqvwcpqoqbo"
+).trim()
+const AUTHORIZATION_ORIGIN =
+  process.env.KUNROUTER_AUTH_ORIGIN?.replace(/\/+$/, "") ||
+  "https://kuncode.120403.xyz"
+const TRUSTED_AUTHORIZATION_DOMAINS = [
+  "wcnmb.si",
+  "wcnmb.fun",
+  "kuncode.120403.xyz",
+  new URL(SITE).hostname,
+  new URL(API).hostname,
+  new URL(AUTHORIZATION_ORIGIN).hostname,
+]
+
+// new-api 的默认换算：500000 quota = 1 美元，站点 /api/status 会覆盖。
+const DEFAULT_QUOTA_PER_UNIT = 500000
+const STATUS_TTL_MS = 10 * 60 * 1000
+// 站点 /api 请求统一超时，免得网络卡住时额度卡和签到一起挂死。
+const REQUEST_TIMEOUT_MS = 10000
+const INVITE_STATUS_TTL_MS = 5 * 60 * 1000
+// 插件加载时要等这次邀请码检查，超时放短一点，别因为站点慢拖住整个插件。
+const INVITE_CHECK_TIMEOUT_MS = 2500
+
+// 拉不到模型列表时的兜底，名字稳定，不至于让供应商空着。
+const DEFAULT_MODELS = {
+  "deepseek-v4.1-flash": "DeepSeek V4.1 Flash",
+  "glm-5.3-flash": "GLM-5.3 Flash",
+  "minimax-m3.1-flash": "MiniMax M3.1 Flash",
+}
+
+const baseModel = {
+  limit: { context: 128000, output: 8192 },
+  tool_call: true,
+}
+
+// 站点级配置（币种符号、quota 换算）不属于任何账号，缓存这里是安全的。
+let statusCache = { at: 0, value: null }
+// 邀请码是否还能用，也做短缓存，避免每次加载插件都打一次站点的脸。
+let inviteCache = { code: "", at: 0, value: null }
+
+async function siteStatus() {
+  const now = Date.now()
+  if (statusCache.value && now - statusCache.at < STATUS_TTL_MS) return statusCache.value
+  try {
+    const res = await fetch(`${SITE}/api/status`, {
+      headers: clientHeaders(),
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+    })
+    if (!res.ok) return statusCache.value ?? {}
+    const data = (await res.json())?.data ?? {}
+    const value = {
+      quotaPerUnit: Number(data.quota_per_unit) || DEFAULT_QUOTA_PER_UNIT,
+      symbol: typeof data.custom_currency_symbol === "string" && data.custom_currency_symbol
+        ? data.custom_currency_symbol
+        : "$",
+      name: data.system_name || "KunRouter",
+    }
+    statusCache = { at: now, value }
+    return value
+  } catch {
+    return statusCache.value ?? {}
+  }
+}
+
+function clientHeaders() {
+  return { "x-kunrouter-client": `opencode-kunrouter-auth/${VERSION}` }
+}
+
+// 站点公开接口 GET /api/invite_codes/public/:code 会告诉我们这个码还能不能用。
+// 用不了（禁用 / 过期 / 名额满）就别再把注册入口摆出来，省得用户点进去才看到报错。
+// 网络抖动时按「未知」处理、仍然展示入口，宁可多给一次机会也别把能用的码藏了。
+async function inviteCodeState(code) {
+  if (!code) return { available: false, unknown: false }
+  const now = Date.now()
+  if (inviteCache.code === code && now - inviteCache.at < INVITE_STATUS_TTL_MS) {
+    return inviteCache.value
+  }
+  let value
+  try {
+    const res = await fetch(
+      `${SITE}/api/invite_codes/public/${encodeURIComponent(code)}`,
+      { headers: clientHeaders(), signal: AbortSignal.timeout(INVITE_CHECK_TIMEOUT_MS) },
+    )
+    if (res.status === 404) {
+      value = { available: false, unknown: false, reason: "invalid" }
+    } else if (!res.ok) {
+      value = { available: true, unknown: true }
+    } else {
+      const body = await res.json().catch(() => null)
+      const data = body?.data
+      if (!data) {
+        value = { available: true, unknown: true }
+      } else {
+        value = {
+          available: data.available === true,
+          unknown: false,
+          reason: typeof data.reason === "string" ? data.reason : "",
+          remaining: Number(data.remaining_registrations) || 0,
+        }
+      }
+    }
+  } catch {
+    value = { available: true, unknown: true }
+  }
+  inviteCache = { code, at: now, value }
+  return value
+}
+
+// 站点存的是不带 sk- 前缀的 Key，遮罩也按去前缀之后算，用来和列表里的 masked_key 对上。
+function maskKey(key) {
+  if (!key) return ""
+  const raw = key.startsWith("sk-") ? key.slice(3) : key
+  if (raw.length <= 4) return "*".repeat(raw.length)
+  if (raw.length <= 8) return `${raw.slice(0, 2)}****${raw.slice(-2)}`
+  return `${raw.slice(0, 4)}**********${raw.slice(-4)}`
+}
+
+// 额度卡上的分组别用授权时的快照：用户可能在控制台改过 Key 的分组。
+// 拿访问令牌列表里按遮罩匹配出真实分组，读不到就交给调用方退回快照。
+async function currentGroup(accessToken, apiKey) {
+  if (!accessToken) return ""
+  try {
+    const res = await fetch(`${SITE}/api/desktop/keys?p=1&page_size=100`, {
+      headers: authHeaders(accessToken),
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+    })
+    if (!res.ok) return ""
+    const body = await res.json().catch(() => null)
+    const items = body?.data?.items
+    if (!Array.isArray(items) || items.length === 0) return ""
+    const masked = maskKey(apiKey)
+    const match =
+      (masked && items.find((item) => item?.masked_key === masked)) ||
+      (items.length === 1 ? items[0] : null)
+    return typeof match?.group === "string" ? match.group : ""
+  } catch {
+    return ""
+  }
+}
+
+function authHeaders(key) {
+  return { authorization: `Bearer ${key}`, ...clientHeaders() }
+}
+
+function tokenOf(auth) {
+  const fromMeta =
+    typeof auth?.metadata?.accessToken === "string"
+      ? auth.metadata.accessToken.trim()
+      : ""
+  if (fromMeta) return fromMeta
+  const key = typeof auth?.key === "string" ? auth.key.trim() : ""
+  return key && !key.startsWith("sk-") ? key : ""
+}
+
+// new-api 有两套凭据：访问令牌只能读 /api（余额、签到），sk- 密钥只能调 /v1。
+// 浏览器授权会把访问令牌放 metadata，把 sk- 密钥放主 key；手工登录也兼容。
+function apiKeyOf(auth) {
+  const meta = auth?.metadata
+  const fromMeta = typeof meta?.apiKey === "string" ? meta.apiKey.trim() : ""
+  if (fromMeta) return fromMeta
+  const key = typeof auth?.key === "string" ? auth.key.trim() : ""
+  return key.startsWith("sk-") ? key : ""
+}
+
+function authorizationError(error) {
+  const message = error instanceof Error ? error.message : String(error)
+  return {
+    type: "failed",
+    error: (message || "KunRouter 浏览器授权失败").slice(0, 480),
+  }
+}
+
+function randomURIToken() {
+  return randomBytes(32).toString("base64url")
+}
+
+function stableInstallationId() {
+  const digest = createHash("sha256")
+    .update(`kunrouter-magpie-v1\0${hostname()}\0${homedir()}`)
+    .digest()
+    .subarray(0, 16)
+  digest[6] = (digest[6] & 0x0f) | 0x50
+  digest[8] = (digest[8] & 0x3f) | 0x80
+  const hex = digest.toString("hex")
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`
+}
+
+function deviceName() {
+  return (hostname() || "Magpie").slice(0, 32)
+}
+
+function sameSecret(left, right) {
+  if (typeof left !== "string" || typeof right !== "string") return false
+  const a = Buffer.from(left)
+  const b = Buffer.from(right)
+  return a.length === b.length && timingSafeEqual(a, b)
+}
+
+function isAllowedAuthorizationURL(value) {
+  try {
+    const url = new URL(String(value || ""))
+    const localHTTP =
+      url.protocol === "http:" &&
+      (url.hostname === "127.0.0.1" || url.hostname === "localhost")
+    const trustedHost = TRUSTED_AUTHORIZATION_DOMAINS.some(
+      (domain) => url.hostname === domain || url.hostname.endsWith(`.${domain}`),
+    )
+    // 授权只应落在授权页，不能是信任域上的任意路径。
+    // 注册和登录走同一个 /desktop/authorize，用 query 区分，所以一条路径就够。
+    const allowedPath = url.pathname === "/desktop/authorize"
+    return (
+      (url.protocol === "https:" || localHTTP) &&
+      trustedHost &&
+      allowedPath
+    )
+  } catch {
+    return false
+  }
+}
+
+async function responseJSON(res) {
+  const body = await res.json().catch(() => null)
+  if (!res.ok || body?.success !== true) {
+    const message =
+      typeof body?.message === "string" && body.message
+        ? body.message
+        : `KunRouter 返回 ${res.status}`
+    throw new Error(message)
+  }
+  return body.data
+}
+
+function listenLoopback(server) {
+  return new Promise((resolve, reject) => {
+    const onError = (error) => reject(error)
+    server.once("error", onError)
+    server.listen(0, "127.0.0.1", () => {
+      server.off("error", onError)
+      const address = server.address()
+      if (!address || typeof address === "string") {
+        reject(new Error("无法分配本地回调端口"))
+        return
+      }
+      resolve(address.port)
+    })
+  })
+}
+
+function waitForLoopbackCallback(server, expectedState, signal) {
+  return new Promise((resolve, reject) => {
+    let settled = false
+    const finish = (fn, value) => {
+      if (settled) return
+      settled = true
+      signal?.removeEventListener("abort", onAbort)
+      fn(value)
+    }
+    const onAbort = () => finish(reject, new Error("浏览器授权已取消"))
+    if (signal?.aborted) {
+      reject(new Error("浏览器授权已取消"))
+      return
+    }
+    signal?.addEventListener("abort", onAbort, { once: true })
+    server.on("request", (req, res) => {
+      if (settled) {
+        res.writeHead(409, { "content-type": "text/plain; charset=utf-8" })
+        res.end("授权请求已处理")
+        return
+      }
+      let callback
+      let code
+      try {
+        callback = new URL(req.url || "/", "http://127.0.0.1")
+        if (
+          callback.protocol !== "http:" ||
+          callback.hostname !== "127.0.0.1" ||
+          callback.pathname !== "/callback"
+        ) {
+          throw new Error("本地回调路径无效")
+        }
+        if (!sameSecret(callback.searchParams.get("state"), expectedState)) {
+          throw new Error("授权状态校验失败")
+        }
+        code = callback.searchParams.get("code")
+        const denied = callback.searchParams.get("error")
+        if (!denied && !code) throw new Error("KunRouter 没有返回授权码")
+        settled = true
+        signal?.removeEventListener("abort", onAbort)
+        if (denied) {
+          res.writeHead(400, { "content-type": "text/plain; charset=utf-8" })
+          res.end("KunRouter 授权未完成，请返回 Magpie。")
+          reject(new Error(denied === "access_denied" ? "已取消 KunRouter 授权" : "KunRouter 拒绝了授权"))
+          return
+        }
+        res.writeHead(200, { "content-type": "text/html; charset=utf-8" })
+        res.end(
+          "<!doctype html><meta charset=\"utf-8\"><title>KunRouter</title>" +
+            "<body style=\"font-family:system-ui,sans-serif;padding:2rem\">" +
+            "<h1>授权完成</h1><p>可以关闭此页面并返回 Magpie。</p></body>",
+        )
+        resolve(code)
+      } catch (error) {
+        res.writeHead(400, { "content-type": "text/plain; charset=utf-8" })
+        res.end("KunRouter 授权回调无效。")
+        if (settled) reject(error)
+      }
+    })
+  })
+}
+
+async function startBrowserAuthorization(signal, options = {}) {
+  const server = createServer()
+  try {
+    const port = await listenLoopback(server)
+    const redirectURI = `http://127.0.0.1:${port}/callback`
+    const state = randomURIToken()
+    const verifier = randomURIToken()
+    const challenge = createHash("sha256").update(verifier).digest("base64url")
+    const res = await fetch(`${SITE}/api/desktop/auth/start`, {
+      method: "POST",
+      headers: { "content-type": "application/json", ...clientHeaders() },
+      body: JSON.stringify({
+        client_id: MAGPIE_CLIENT_ID,
+        installation_id: stableInstallationId(),
+        device_name: deviceName(),
+        redirect_uri: redirectURI,
+        state,
+        code_challenge: challenge,
+        code_challenge_method: "S256",
+      }),
+      signal,
+    })
+    const started = await responseJSON(res)
+    if (!isAllowedAuthorizationURL(started?.authorization_url)) {
+      throw new Error("KunRouter 返回了无效的授权地址")
+    }
+    const authorizationURL = new URL(started.authorization_url)
+    if (options.registration) {
+      authorizationURL.searchParams.set("mode", "register")
+      authorizationURL.searchParams.set("invite_code", INVITE_CODE)
+    }
+    const callbackPromise = waitForLoopbackCallback(server, state, signal)
+    const closeOnAbort = () => server.close()
+    signal?.addEventListener("abort", closeOnAbort, { once: true })
+    callbackPromise.catch(() => {})
+    return {
+      url: authorizationURL.toString(),
+      instructions: options.registration
+        ? "没有账号时，浏览器会打开注册页并自动填入 Magpie 邀请码；注册并登录后会自动继续授权。"
+        : "请在浏览器中登录 KunRouter 并确认授权；完成后 Magpie 会自动继续。",
+      method: "auto",
+      async callback() {
+        try {
+          const code = await callbackPromise
+          const exchange = await fetch(`${SITE}/api/desktop/auth/exchange`, {
+            method: "POST",
+            headers: { "content-type": "application/json", ...clientHeaders() },
+            body: JSON.stringify({
+              code,
+              code_verifier: verifier,
+              redirect_uri: redirectURI,
+            }),
+            signal,
+          })
+          const data = await responseJSON(exchange)
+          const accessToken = String(data?.access_token || "").trim()
+          const apiKey = String(data?.api_key || "").trim()
+          const group = String(data?.group || "").trim()
+          if (!accessToken || !apiKey.startsWith("sk-")) {
+            throw new Error("KunRouter 返回的凭据不完整")
+          }
+          const username =
+            data?.user?.email ||
+            data?.user?.username ||
+            data?.user?.display_name ||
+            undefined
+          return {
+            type: "success",
+            key: apiKey,
+            accountId:
+              data?.user?.id != null ? String(data.user.id) : undefined,
+            metadata: {
+              accessToken,
+              apiKey,
+              mode: "browser",
+              username,
+              group: group || undefined,
+              expiresAt: Number(data?.expires_at) || undefined,
+            },
+          }
+        } catch (error) {
+          return authorizationError(error)
+        } finally {
+          signal?.removeEventListener("abort", closeOnAbort)
+          server.close()
+        }
+      },
+    }
+  } catch (error) {
+    server.close()
+    return authorizationError(error)
+  }
+}
+
+// /v1/models：只有 sk- 密钥能调，访问令牌到这里是 401。
+async function listModels(apiKey) {
+  const res = await fetch(`${API}/v1/models`, {
+    headers: authHeaders(apiKey),
+    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+  })
+  return { ok: res.ok, status: res.status, res }
+}
+
+// /api/user/self：余额查这里，也是校验令牌是否还有效的唯一办法。
+async function fetchSelf(key) {
+  let res
+  try {
+    res = await fetch(`${SITE}/api/user/self`, {
+      headers: authHeaders(key),
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+    })
+  } catch (e) {
+    return { error: `KunRouter 连不上：${e}` }
+  }
+  if (res.status === 401 || res.status === 403) {
+    return { error: "KunRouter 说这个令牌无效或已过期", expired: true }
+  }
+  if (!res.ok) return { error: `KunRouter 返回 ${res.status}` }
+  const body = await res.json().catch(() => null)
+  if (!body?.success || !body?.data) {
+    const code = String(body?.code || body?.message_key || "")
+    if (code.includes("ACCESS_TOKEN_LEGACY_RETIRED")) {
+      return { error: "这个令牌是旧的访问令牌，站点已经退役了；模拟账号管理页 → 安全设置里重新生成一个", expired: true }
+    }
+    if (code.includes("AUTH_UNAUTHORIZED")) {
+      return { error: "这个令牌不是访问令牌；余额要后台安全设置里生成的那种，不是 sk- 开头的 API 密钥", expired: true }
+    }
+    return { error: body?.message || "KunRouter 返回了读不懂的内容" }
+  }
+  return { user: body.data }
+}
+
+// /api/subscription/self：当前订阅、钱包/订阅计费优先级。
+// /api/subscription/plans：把 plan_id 换成套餐名；即使这里失败，订阅本身仍然能显示。
+async function fetchSubscriptions(accessToken) {
+  try {
+    const [selfRes, plansRes] = await Promise.all([
+      fetch(`${SITE}/api/subscription/self`, {
+        headers: authHeaders(accessToken),
+        signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+      }),
+      fetch(`${SITE}/api/subscription/plans`, {
+        headers: authHeaders(accessToken),
+        signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+      }),
+    ])
+    if (selfRes.status === 401) {
+      return { error: "KunRouter 说这个令牌无效或已过期", expired: true }
+    }
+    if (selfRes.status === 403) {
+      return { error: "站点还没有开放 Magpie 读取订阅额度" }
+    }
+    if (!selfRes.ok) return { error: `订阅接口返回 ${selfRes.status}` }
+    const selfBody = await selfRes.json().catch(() => null)
+    if (!selfBody?.success || !selfBody?.data) {
+      return { error: selfBody?.message || "订阅接口返回了读不懂的内容" }
+    }
+
+    let plans = []
+    if (plansRes.ok) {
+      const plansBody = await plansRes.json().catch(() => null)
+      if (Array.isArray(plansBody?.data)) plans = plansBody.data
+    }
+    const data = selfBody.data
+    return {
+      billingPreference:
+        typeof data.billing_preference === "string"
+          ? data.billing_preference
+          : "subscription_first",
+      subscriptions: Array.isArray(data.subscriptions) ? data.subscriptions : [],
+      plans,
+    }
+  } catch (e) {
+    return { error: `KunRouter 订阅接口连不上：${e}` }
+  }
+}
+
+function durationLabel(seconds) {
+  const value = Math.max(0, Number(seconds) || 0)
+  if (value > 0 && value % 86400 === 0) return `${value / 86400} 天`
+  if (value > 0 && value % 3600 === 0) return `${value / 3600} 小时`
+  if (value > 0 && value % 60 === 0) return `${value / 60} 分钟`
+  return `${Math.round(value)} 秒`
+}
+
+function quotaWindowLabel(seconds) {
+  const value = Number(seconds)
+  if (value === 86400) return "日额度"
+  if (value === 604800) return "周额度"
+  if (value >= 28 * 86400 && value <= 31 * 86400) return "月额度"
+  return `${durationLabel(seconds)}额度`
+}
+
+// 用户在控制台删掉 Key 后，插件手里的 sk- 立刻失效，但访问令牌还在。
+// 用访问令牌重签一把同名 Key，再把新凭据写回 Magpie，下一次请求就能接着用。
+const RECOVERY_COOLDOWN_MS = 60 * 1000
+const recoveryAttempts = new Map() // 访问令牌 -> { at, promise }
+
+async function recoverApiKey(accessToken, group) {
+  if (!accessToken) return null
+  const cached = recoveryAttempts.get(accessToken)
+  if (cached && Date.now() - cached.at < RECOVERY_COOLDOWN_MS) {
+    return cached.promise.catch(() => null)
+  }
+  const promise = (async () => {
+    const res = await fetch(`${SITE}/api/desktop/keys`, {
+      method: "POST",
+      headers: { "content-type": "application/json", ...authHeaders(accessToken) },
+      // group 为空时站点按账号默认分组签发，和首次授权一致。
+      body: JSON.stringify({ name: "Magpie", group: group || undefined }),
+      signal: AbortSignal.timeout(10000),
+    })
+    const data = await responseJSON(res)
+    const key = typeof data?.key === "string" ? data.key.trim() : ""
+    if (!key.startsWith("sk-")) return null
+    return { key, group: String(data?.group || ""), id: data?.id }
+  })()
+  recoveryAttempts.set(accessToken, { at: Date.now(), promise })
+  return promise.catch(() => null)
+}
+
+// 把新 Key 写回 Magpie 的账号；写不进去也只是一次性生效，不影响这次请求。
+async function saveRecoveredAuth(client, auth, recovered) {
+  if (!client?.auth?.set) return
+  const metadata = { ...(auth?.metadata ?? {}) }
+  metadata.apiKey = recovered.key
+  if (recovered.group) metadata.group = recovered.group
+  if (recovered.id != null) metadata.apiKeyId = recovered.id
+  try {
+    await client.auth.set({
+      path: { id: PROVIDER },
+      body: {
+        type: "api",
+        key: recovered.key,
+        accountId: auth?.accountId,
+        metadata,
+      },
+    })
+  } catch {
+    /* 写回失败就等下一次 401 再试 */
+  }
+}
+
+export const KunRouterPlugin = async (input) => {
+  // magpie 的选项框：plugins.json 里这一项的 options，按供应商 id 读。
+  const opt = (key, fallback) => {
+    const v = input?.magpie?.option?.(PROVIDER, key)
+    return typeof v === "boolean" ? v : fallback
+  }
+  // 直连域名绕开 Cloudflare 的 100 秒上限；关掉就走主站 /v1。
+  const apiBase = () => (opt("direct_api", true) ? API : SITE)
+
+  // 注册入口要先确认邀请码还能用，用不了就别把入口摆出来（#6）。
+  // 关掉 registration_entry 开关也能隐藏它（#12）。
+  const inviteState =
+    Boolean(INVITE_CODE) && opt("registration_entry", true)
+      ? await inviteCodeState(INVITE_CODE)
+      : null
+  const showInvite = Boolean(inviteState?.available)
+  const inviteLabel =
+    Number(inviteState?.remaining) > 0
+      ? `没有账号？注册并领取鸡蛋（剩 ${inviteState.remaining} 个名额）`
+      : "没有账号？注册并领取鸡蛋（仅新用户）"
+
+  return {
+  config: async (cfg) => {
+    cfg.provider ??= {}
+    cfg.provider[PROVIDER] ??= {
+      name: "KunRouter",
+      npm: "@ai-sdk/openai-compatible",
+      api: `${apiBase()}/v1`,
+      endpoint: `${apiBase()}/v1`,
+      website: SITE,
+      keys: `${SITE}/console/token`,
+      models: Object.fromEntries(
+        Object.entries(DEFAULT_MODELS).map(([id, name]) => [id, { ...baseModel, name }]),
+      ),
+    }
+  },
+
+  auth: {
+    provider: PROVIDER,
+    // 一台机器只留一个账号：重新登录（包括手动填 Key）覆盖原来那条，
+    // 而不是另开一个 kunrouter#xxxxxx。验证码/密钥填错想重来，
+    // 直接再走一遍登录即可，不用先登出。
+    single: true,
+    maxConcurrency: 8,
+    options: [
+      {
+        key: "direct_api",
+        label: "走直连域名",
+        description:
+          "默认走直连域名，避免长请求被 Cloudflare 的 100 秒上限打断；关掉改走主站。",
+        default: true,
+      },
+      {
+        key: "period_window",
+        label: "显示订阅额度",
+        description:
+          "开（默认）：显示订阅套餐的总额、已用、剩余、到期时间和滚动窗口。关掉就只看钱包余额。",
+        default: true,
+      },
+      {
+        key: "registration_entry",
+        label: "显示注册入口",
+        description: "登录页显示注册入口；邀请码不可用时自动隐藏。",
+        default: true,
+      },
+    ],
+    methods: [
+      {
+        type: "oauth",
+        label: "浏览器授权（推荐）",
+        async authorize(_inputs, { signal } = {}) {
+          return startBrowserAuthorization(signal)
+        },
+      },
+      ...(showInvite
+        ? [
+            {
+              type: "oauth",
+              label: inviteLabel,
+              async authorize(_inputs, { signal } = {}) {
+                return startBrowserAuthorization(signal, { registration: true })
+              },
+            },
+          ]
+        : []),
+      {
+        // 手工兜底：授权服务不可用时，仍可分别填写 PAT 和 sk- 密钥。
+        type: "api",
+        // 插件自己收两把钥匙；关掉 magpie 额外的 API key 输入框，免得重复粘贴。
+        keyless: true,
+        label: "手动填写 / 更换访问令牌 + API 密钥",
+        placeholder: "两把钥匙分别粘贴",
+        prompts: [
+          {
+            type: "password",
+            key: "accessToken",
+            message: "访问令牌（后台「个人设置 → 安全设置」生成，用来读余额和签到）",
+            placeholder: "不是 sk- 开头的那串",
+            validate: (v) => (v && v.trim().length >= 8 ? undefined : "令牌太短，先确认复制全了"),
+          },
+          {
+            type: "password",
+            key: "apiKey",
+            message: "API 密钥（后台「令牌」页生成，sk- 开头，用来请求模型；留空就只能看余额）",
+            placeholder: "sk-…",
+            validate: (v) => (!v || v.trim().startsWith("sk-") ? undefined : "API 密钥是 sk- 开头的，别把访问令牌填这儿"),
+          },
+        ],
+        authorize: async (inputs) => {
+          const token = String(inputs?.accessToken ?? "").trim()
+          const apiKey = String(inputs?.apiKey ?? "").trim()
+          if (!token) return { type: "failed", error: "访问令牌不能为空" }
+
+          const self = await fetchSelf(token)
+          if (self.error) {
+            return {
+              type: "failed",
+              error: `${self.error}（这一栏要的是后台安全设置生成的访问令牌，不是 sk- 开头的 API 密钥）`,
+            }
+          }
+
+          // 顺手验一下 sk- 能不能列模型，省得进了列表才发现拉不到。
+          if (apiKey) {
+            const probe = await listModels(apiKey).catch(() => null)
+            if (!probe) return { type: "failed", error: "API 密钥连不上 /v1/models，确认一下是不是复制全了" }
+            if (!probe.ok) return { type: "failed", error: `API 密钥被拒绝（HTTP ${probe.status}）` }
+          }
+
+          const name = self.user?.email || self.user?.username || self.user?.display_name
+          return {
+            type: "success",
+            key: token,
+            accountId: self.user?.id != null ? String(self.user.id) : undefined,
+            metadata: { mode: "token", username: name, apiKey: apiKey || undefined },
+          }
+        },
+      },
+    ],
+
+    async loader(getAuth) {
+      const auth = await getAuth()
+      if (auth?.type !== "api") return {}
+      const client = input?.client
+      const apiKey = apiKeyOf(auth)
+      // 只有访问令牌、没有 sk- 密钥时，/v1 必然 401（访问令牌只能读 /api）。
+      // 与其让请求打出去 401，不如当场给一句能看懂的话：这把账号只能看余额和签到。
+      if (!apiKey) {
+        return {
+          baseURL: `${apiBase()}/v1`,
+          async fetch() {
+            return new Response(
+              JSON.stringify({
+                error: {
+                  type: "invalid_request_error",
+                  message:
+                    "这个账号只填了访问令牌，没有 sk- API 密钥，不能调用模型。请在 KunRouter 后台「令牌」新建一把 sk- 密钥，或改用浏览器授权。",
+                },
+              }),
+              { status: 401, headers: { "content-type": "application/json" } },
+            )
+          },
+        }
+      }
+      let key = apiKey
+      return {
+        baseURL: `${apiBase()}/v1`,
+        async fetch(input, init) {
+          const send = (secret, base) => {
+            const headers = new Headers(init?.headers)
+            headers.set("authorization", `Bearer ${secret}`)
+            for (const [k, v] of Object.entries(clientHeaders())) headers.set(k, v)
+            // loader 已经用 apiBase 拼好完整 URL，回退时把直连域名换回主站。
+            const target =
+              base === SITE && typeof input === "string" && input.startsWith(API)
+                ? `${SITE}${input.slice(API.length)}`
+                : input
+            return fetch(target, { ...init, headers })
+          }
+          let res
+          try {
+            res = await send(key, apiBase())
+          } catch (error) {
+            // 直连域名网络层挂了（DNS / 连不上）时回退一次主站，别让明明还能用的站白等。
+            const replayable =
+              init?.body == null ||
+              typeof init.body === "string" ||
+              init.body instanceof Uint8Array ||
+              init.body instanceof ArrayBuffer
+            if (apiBase() === API && replayable) {
+              res = await send(key, SITE)
+            } else {
+              throw error
+            }
+          }
+          // Key 被控制台删掉后 /v1 会直接 401。访问令牌还能用就重签一把再试。
+          if (res.status === 401) {
+            const recovered = await recoverApiKey(tokenOf(auth), auth?.metadata?.group)
+            if (recovered?.key) {
+              key = recovered.key
+              await saveRecoveredAuth(client, auth, recovered)
+              // 请求体已经被读掉（流式上传）时没法重放，留给下一次请求。
+              const replayable =
+                init?.body == null ||
+                typeof init.body === "string" ||
+                init.body instanceof Uint8Array ||
+                init.body instanceof ArrayBuffer
+              if (replayable) res = await send(key, apiBase())
+            }
+          }
+          return res
+        },
+      }
+    },
+
+    // 钱包余额和订阅额度分开显示，避免把订阅消耗误当成钱包扣费。
+    // 只有一把钥匙时只显示能读到的那一个，不假装知道另一边的数。
+    async usage(getAuth) {
+      const auth = await getAuth()
+      if (auth?.type !== "api") return { windows: [] }
+      const token = tokenOf(auth)
+      const apiKey = apiKeyOf(auth)
+      if (!token && !apiKey) return { windows: [] }
+
+      const status = await siteStatus()
+      const unit = status.quotaPerUnit || DEFAULT_QUOTA_PER_UNIT
+      const sym = status.symbol || "$"
+      // 窗口单位跟着站点币种走（本站是 🥚），别写死成美元。
+      const currencyUnit = sym && sym !== "$" ? sym : "USD"
+      const money = (n) => `${sym} ${n.toFixed(2)}`
+      const windows = []
+      const showSubscriptions = opt("period_window", true)
+
+      // 只填了 sk- 的账号到这儿为止。
+      if (!token) return { plan: "API 密钥", windows }
+
+      const [self, subscriptionData] = await Promise.all([
+        fetchSelf(token),
+        showSubscriptions ? fetchSubscriptions(token) : Promise.resolve(null),
+      ])
+      if (self.error) {
+        const out = { windows }
+        if (self.expired) out.signIn = "expired"
+        if (!windows.length) out.error = self.error
+        return out
+      }
+
+      const left = Number(self.user?.quota) || 0
+      const spent = Number(self.user?.used_quota) || 0
+      const available = left / unit
+      const walletWindow = {
+        name: "钱包",
+        balance: available,
+        unit: currencyUnit,
+        display: `${sym} ${available.toFixed(2)} 可用 · 已用 ${money(spent / unit)}`,
+      }
+
+      const planTitles = new Map()
+      for (const item of subscriptionData?.plans || []) {
+        const plan = item?.plan
+        if (plan?.id != null && typeof plan.title === "string") {
+          planTitles.set(Number(plan.id), plan.title)
+        }
+      }
+
+      // 分组别用授权时的快照：用户可能在控制台改过 Key 的分组。读一次真实分组，读不到再退回。
+      const liveGroup = apiKey ? await currentGroup(token, apiKey) : ""
+      const group = liveGroup
+        ? liveGroup
+        : self.user?.group
+          ? self.user.group
+          : auth.metadata?.group
+            ? `${auth.metadata.group}（授权时）`
+            : "默认分组"
+
+      const activeSubscriptions = (subscriptionData?.subscriptions || [])
+        .map((item) => item?.subscription)
+        .filter((sub) => sub?.status === "active")
+      const subscriptionWindows = []
+      for (const sub of activeSubscriptions) {
+        const title =
+          planTitles.get(Number(sub.plan_id)) || `订阅 #${sub.plan_id || "?"}`
+        const total = Number(sub.amount_total) || 0
+        const used = Math.max(0, Number(sub.amount_used) || 0)
+        const remaining = Math.max(0, total - used)
+        const totalAmount = total / unit
+        const remainingAmount = remaining / unit
+        const percent = total > 0 ? (used / total) * 100 : 0
+        const endHint = sub.end_time
+          ? new Date(Number(sub.end_time) * 1000).toLocaleDateString("zh-CN")
+          : ""
+        const allowWalletOverflow = sub.allow_wallet_overflow !== false
+
+        // 滚动窗口套餐把额度全放在 quota_windows 里，amount_total 是 0；
+        // 这时不画一条 0 / 0 的空进度条。
+        if (total > 0) {
+          subscriptionWindows.push({
+            name: title,
+            used: percent,
+            amount: used / unit,
+            limit: totalAmount,
+            unit: currencyUnit,
+            ...(sub.start_time && sub.end_time
+              ? {
+                  span: Math.max(
+                    0,
+                    Number(sub.end_time) - Number(sub.start_time),
+                  ),
+                }
+              : {}),
+            ...(sub.end_time
+              ? {
+                  runsOutAt: new Date(Number(sub.end_time) * 1000).toISOString(),
+                  runsOut: remainingAmount,
+                }
+              : {}),
+            // 套餐允许钱包兜底时，用完订阅不会让账号停摆。
+            aside: allowWalletOverflow,
+            display: `剩余 ${money(remainingAmount)} / ${money(totalAmount)}${endHint ? ` · ${endHint} 到期` : ""}`,
+          })
+        }
+
+        for (const window of Array.isArray(sub.quota_windows)
+          ? sub.quota_windows
+          : []) {
+          const windowLimit = Number(window?.quota_limit) || 0
+          const windowUsed = Math.max(0, Number(window?.used) || 0)
+          if (windowLimit <= 0) continue
+          const windowRemaining = Math.max(0, windowLimit - windowUsed)
+          const windowPercent = (windowUsed / windowLimit) * 100
+          const nextRelease = Number(window?.next_release_at) || 0
+          subscriptionWindows.push({
+            name:
+              activeSubscriptions.length > 1
+                ? `${title} · ${quotaWindowLabel(window?.window_seconds)}`
+                : quotaWindowLabel(window?.window_seconds),
+            used: windowPercent,
+            amount: windowUsed / unit,
+            limit: windowLimit / unit,
+            unit: currencyUnit,
+            span: Number(window?.window_seconds) || 0,
+            ...(nextRelease
+              ? { resetsAt: new Date(nextRelease * 1000).toISOString() }
+              : {}),
+            aside: allowWalletOverflow,
+            display: `剩余 ${money(windowRemaining / unit)} / ${money(windowLimit / unit)}`,
+          })
+        }
+      }
+
+      const subscriptionFirst =
+        subscriptionData?.billingPreference !== "wallet_first" &&
+        subscriptionData?.billingPreference !== "wallet_only"
+      const orderedWindows = subscriptionFirst
+        ? [...subscriptionWindows, walletWindow]
+        : [walletWindow, ...subscriptionWindows]
+
+      windows.unshift(...orderedWindows)
+      if (subscriptionData?.error) {
+        windows.push({
+          name: "订阅",
+          aside: true,
+          display: "订阅额度暂不可用",
+        })
+      }
+
+      const subscriptionTitles = activeSubscriptions
+        .map(
+          (sub) =>
+            planTitles.get(Number(sub.plan_id)) || `订阅 #${sub.plan_id || "?"}`,
+        )
+        .filter((title, index, titles) => titles.indexOf(title) === index)
+      const preferenceSuffix =
+        subscriptionData?.billingPreference === "wallet_first"
+          ? " · 钱包优先"
+          : subscriptionData?.billingPreference === "subscription_only"
+            ? " · 仅订阅"
+            : subscriptionData?.billingPreference === "wallet_only"
+              ? " · 仅钱包"
+              : ""
+      const planTitle = subscriptionTitles.length
+        ? subscriptionTitles.join(" / ")
+        : ""
+      const plan = `${planTitle ? `${planTitle} · ` : ""}${group}${preferenceSuffix}`
+      const until = activeSubscriptions.reduce(
+        (latest, sub) => Math.max(latest, Number(sub.end_time) || 0),
+        0,
+      )
+
+      return {
+        plan,
+        user: self.user?.email || self.user?.username || undefined,
+        balance: money(available),
+        ...(until ? { until: new Date(until * 1000).toISOString() } : {}),
+        windows,
+      }
+    },
+
+    // 站点开着每日签到（/api/status 的 checkin_enabled），顺手替账号签了。
+    async checkin(getAuth) {
+      const auth = await getAuth()
+      const key = tokenOf(auth)
+      if (!key) return { outcome: "ineligible" }
+
+      // 与签到请求并行读取换算比例，避免成功后再等一次站点请求。
+      const status = siteStatus()
+      let res
+      try {
+        res = await fetch(`${SITE}/api/user/checkin`, {
+          method: "POST",
+          headers: { ...authHeaders(key), "content-type": "application/json" },
+          body: "{}",
+          signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+        })
+      } catch (e) {
+        return { outcome: "failed", message: `KunRouter 连不上：${e}` }
+      }
+
+      if (res.status === 401 || res.status === 403) {
+        throw Object.assign(new Error("KunRouter 说这个令牌无效或已过期"), { signIn: "expired" })
+      }
+
+      const body = await res.json().catch(() => ({}))
+      const message = typeof body?.message === "string" ? body.message : ""
+      if (!res.ok || body?.success === false) {
+        // 「今天已签到」是正常的 done，不是失败。
+        if (/已签到|已经签到|already/i.test(message)) return { outcome: "done", message }
+        return { outcome: "failed", message: message || `KunRouter 返回 ${res.status}` }
+      }
+
+      // 签到接口返回原始 quota，和钱包一样换算成站点显示的额度。
+      const quota = Number(body?.data?.quota_awarded ?? body?.data?.quota ?? 0) || 0
+      const credit = quota ? quota / ((await status).quotaPerUnit || DEFAULT_QUOTA_PER_UNIT) : 0
+      return {
+        outcome: "claimed",
+        credit: credit || undefined,
+        message: message || (body?.data?.checkin_date ? `已签到 ${body.data.checkin_date}` : "签到完成"),
+      }
+    },
+  },
+
+  // 站点的模型列表是公开的（要 key），拉一次就够了，拉不到就保留上一份。
+  provider: {
+    id: PROVIDER,
+    async models(provider, { auth } = {}) {
+      if (auth?.type !== "api") return provider.models
+      const key = apiKeyOf(auth)
+      if (!key) return provider.models
+
+      let list
+      try {
+        const res = await fetch(`${API}/v1/models`, {
+          headers: authHeaders(key),
+          signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+        })
+        if (!res.ok) return provider.models
+        const body = await res.json()
+        list = Array.isArray(body?.data) ? body.data : []
+      } catch {
+        return provider.models
+      }
+
+      const out = {}
+      for (const m of list) {
+        const id = typeof m?.id === "string" ? m.id : ""
+        if (!id) continue
+        out[id] = { ...baseModel, name: id }
+      }
+      return Object.keys(out).length ? out : provider.models
+    },
+  },
+  }
+}
+
+// 给测试用，别从入口导出别的函数：magpie 会把每个导出函数都当插件调用。
+export const _internal = {
+  INVITE_CODE,
+  apiKeyOf,
+  currentGroup,
+  fetchSelf,
+  fetchSubscriptions,
+  inviteCodeState,
+  isAllowedAuthorizationURL,
+  maskKey,
+  recoverApiKey,
+  siteStatus,
+  stableInstallationId,
+  startBrowserAuthorization,
+  tokenOf,
+  DEFAULT_MODELS,
+  DEFAULT_QUOTA_PER_UNIT,
+}

package/package.json

@@ -1,6 +1,26 @@
 {
   "name": "opencode-kunrouter-auth",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.8.3",
+  "description": "KunRouter (wcnmb.si) provider for OpenCode and magpie — browser sign-in, wallet and subscription quota, daily check-in",
+  "type": "module",
+  "main": "./index.mjs",
+  "scripts": {
+    "test": "node browser-auth.test.mjs"
+  },
+  "files": ["index.mjs", "README.md", "CHANGELOG.md"],
+  "keywords": ["opencode", "opencode-plugin", "magpie", "kunrouter", "new-api"],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MY-Final/opencode-kunrouter-auth.git"
+  },
+  "magpie": {
+    "name": "KunRouter",
+    "icon": "https://wcnmb.si/logo.png",
+    "maxConcurrency": 8,
+    "summary": {
+      "en": "KunRouter relay: browser sign-in, wallet and subscription quota, daily check-in.",
+      "zh": "KunRouter 中转：浏览器一键授权、钱包与订阅额度、每日签到。"
+    }
+  }
+}