magicrew-auth 0.3.16 → 0.3.23

package/src/hooks/usage.mjs

@@ -1,12 +1,34 @@
 // ⑤ auth.usage(getAuth) —— 额度
 //
-// 画进度条，**同时是路由排序输入**：`used` 缺了会被当成 0% = 满额，
-// 空号反而排到队首。
+// 超级麦吉的积分是「预付钱包」：`/api/v1/quota/points/total` 只回当前余额
+// `total_points` 和一批会过期的明细（`expiring_quota_details`），没有总量、
+// 没有已消耗；积分流水接口恒 500。钱包没有分母，不能编造 used/limit 百分比。
 //
-// ⚠ 预充值积分制放 aside：只显示余额、不参与排序；余额 0 时 used 置 100，
-//   让它老老实实排到最后。
+// magpie 0.1.1790（issue #3950）起，窗口可以直接报余额：
+//
+//   windows: [{
+//     name: "积分余额",
+//     balance: 6291,   // 还剩多少，单位见 unit
+//     unit: "积分",
+//     // 可选：runsOutAt / runsOut / display / model / models / notModels
+//   }]
+//
+// 不写 used / limit / aside —— 宿主把余额当读数额度，不画百分比；同 provider、
+// 同单位的账号按余额从多到少排，余额 0 视为用完。`runsOutAt` 取最早过期的
+// 一批，让 smart 路由知道谁的积分先失效。
+//
+// 钱包只有一个总数，但过期批次有先后：今日 23:59 到期的每日积分、其他限时
+// 批次、永久积分要看得见。它们在余额窗口之后作为 `aside` 文本行显示（只展示，
+// 不进 Allowance.Left —— 否则最小的那一条会把总余额压低）。
+//
+// 不要再把「今日 / 限时 / 永久」做成带 used/limit 的假百分比窗口；旧写法是
+// 宿主支持余额之前的临时协议，见 CHANGELOG 0.3.20。
+
+import { fetchPoints, SITES } from "../api.mjs"
 
-import { fetchPoints } from "../api.mjs"
+// 每日登录积分：国内 +200/天、国际 +50/天（实测，见 docs/internals.md）。
+// 今日批次的分母，只用于展示「今日还剩 / 今日额度」。
+const DAILY_LOGIN_GIFT = { cn: 200, intl: 50 }
 
 export function makeUsage(c) {
   return async (getAuth) => {
@@ -14,27 +36,107 @@ export function makeUsage(c) {
     if (!auth) return { error: "未登录", windows: [] }
     try {
       const p = await fetchPoints(auth.jwt, auth.org, c.host)
-      const nextExpiry = p.expiring?.[0]?.expiresAt
+      const total = Number(p?.total ?? 0)
+      if (!Number.isFinite(total)) return { error: "积分接口没有返回可用余额", windows: [] }
+      const batches = Array.isArray(p?.expiring) ? p.expiring : []
+      const windows = [{
+        name: "积分余额",
+        balance: total,
+        unit: "积分",
+        display: total > 0 ? `${fmt(total)} 积分` : "已耗尽",
+        ...(total > 0 ? runsOutOf(batches) : {}),
+      }]
+
+      if (total > 0) {
+        const today = beijingDay(Date.now())
+        const todayBatches = batches.filter((b) => b.points > 0 && beijingDay(parseServerTime(b.expiresAt)) === today)
+        const todayLeft = sum(todayBatches)
+        const timedLeft = sum(batches)
+        const timedRest = Math.max(0, timedLeft - todayLeft)
+        const permanent = Math.max(0, total - timedLeft)
+        const dailyCap = DAILY_LOGIN_GIFT[c.host === SITES.cn.host ? "cn" : "intl"]
+
+        // 只展示的批次行：没有 used/limit/balance，宿主把它们当 aside 文本，
+        // 不参与 Allowance.Left；路由仍只看上面的总余额。
+        if (todayLeft > 0) {
+          windows.push({
+            name: "今日积分",
+            display: `${fmt(todayLeft)} / ${fmt(dailyCap)} 积分 · 今日 23:59 到期`,
+            unit: "积分",
+            aside: true,
+          })
+        }
+        if (timedRest > 0) {
+          const next = pickEarliest(batches.filter((b) => !todayBatches.includes(b)))
+          const when = next ? ` · 最早 ${beijingDate(next.ms)} 到期` : ""
+          windows.push({
+            name: "限时积分",
+            display: `${fmt(timedRest)} 积分${when}`,
+            unit: "积分",
+            aside: true,
+          })
+        }
+        if (permanent > 0) {
+          windows.push({
+            name: "永久积分",
+            display: `${fmt(permanent)} 积分`,
+            unit: "积分",
+            aside: true,
+          })
+        }
+      }
+
       return {
-        plan: p.total > 0 ? "积分制" : "已耗尽",
-        balance: `${p.total.toLocaleString("zh-CN")} 积分`,
-        windows: [
-          p.total > 0
-            ? {
-                name: "积分余额",
-                used: 0,
-                display: `${p.total.toLocaleString("zh-CN")} 积分`,
-                amount: 0,
-                limit: p.total,
-                unit: "积分",
-                resetsAt: nextExpiry,
-                aside: true,
-              }
-            : { name: "积分余额", used: 100, display: "已耗尽" },
-        ],
+        plan: total > 0 ? "积分制" : "已耗尽",
+        balance: `${fmt(total)} 积分`,
+        windows,
       }
     } catch (e) {
       return { error: String(e?.message ?? e), windows: [] }
     }
   }
 }
+
+/** 最早失效的那批 → magpie 的 `runsOutAt` / `runsOut`。 */
+function runsOutOf(expiring) {
+  const next = pickEarliest(expiring)
+  if (!next) return {}
+  return {
+    runsOutAt: new Date(next.ms).toISOString(),
+    runsOut: next.points,
+  }
+}
+
+function pickEarliest(expiring) {
+  const list = Array.isArray(expiring) ? expiring : []
+  let best = null
+  for (const e of list) {
+    const pts = Number(e?.points ?? 0)
+    const ms = parseServerTime(e?.expiresAt)
+    if (!(pts > 0) || ms === null) continue
+    if (!best || ms < best.ms) best = { points: pts, ms }
+  }
+  return best
+}
+
+/** `"2026-10-28 23:59:59"` → 毫秒；解析不了返回 null */
+function parseServerTime(s) {
+  const m = /^(\d{4})-(\d{2})-(\d{2})[ T](\d{2}):(\d{2}):(\d{2})/.exec(String(s ?? ""))
+  if (!m) return null
+  const [, y, mo, d, h, mi, se] = m
+  const ms = new Date(Number(y), Number(mo) - 1, Number(d), Number(h), Number(mi), Number(se)).getTime()
+  return Number.isFinite(ms) ? ms : null
+}
+
+/** 北京时间的日期键 `YYYY-MM-DD`（服务端的时间都是 UTC+8） */
+function beijingDay(ms) {
+  if (ms === null) return ""
+  return new Date(ms + 8 * 3600e3).toISOString().slice(0, 10)
+}
+
+function beijingDate(ms) {
+  return beijingDay(ms)
+}
+
+const sum = (list) => list.reduce((n, b) => n + Number(b?.points ?? 0), 0)
+const fmt = (n) => Number(n).toLocaleString("zh-CN")

package/src/keys.mjs

@@ -28,6 +28,7 @@ import {
   otherSlot,
   currentKey,
   safeAccount,
+  listAccounts,
 } from "./key-store.mjs"
 
 /**
@@ -37,6 +38,52 @@ export function accountOf(auth) {
   return safeAccount(auth?.org || auth?.accountId || auth?.uid || "default")
 }
 
+/** 这个账号的 store 里到底有没有东西（登录过 / 接管过 / 续过期都算） */
+function storeHasIdentity(siteId, account) {
+  const st = readStore(siteId, account)
+  return !!(
+    st?.refreshToken ||
+    st?.keys?.a?.apiKey ||
+    st?.keys?.b?.apiKey
+  )
+}
+
+/**
+ * 这条请求属于哪个账号的 key 槽 —— 比 `accountOf` 多一层兜底。
+ *
+ * 为什么要多这一层（2026-10-28 实测的链路）：
+ *
+ *   网关路径下（ZCode 等 agent 从 magpie 的 `/v1/chat/completions` 进来），
+ *   `getAuth()` 返回的 auth **可能不带 org / accountId / uid** ——
+ *   于是 `accountOf()` 落到 `"default"`，`readStore(c.id, "default")` 读不到
+ *   真实账号的槽，`ensureKey` 只能退到「从 magpie 存的凭据接管一次」用
+ *   `auth.access`；而它过了 2 小时就 403，表现成
+ *   `502 {"message":"超级麦吉 did not stream: token无效"}`。
+ *
+ * 兜底只做**一半**，这是关键：
+ *
+ *   · 该站点**恰好一个账号**（绝大多数用户）→ 那就是它，安全
+ *   · 0 个 → 交给原来的「首次接管」
+ *   · **≥2 个 → 不猜**，退回 `"default"`
+ *
+ * 为什么不猜：key 与账号一一对应，用错账号的 key 就是拿别人的积分、别人的
+ * 组织出话，而且本地看不出来（不是报错，是错账）。多账号场景宁可让这次请求
+ * 失败，也不要借身份 —— 判据见 docs/internals.md 第十五节。
+ *
+ * ⚠ 多账号 + 网关路径的组合目前仍然无解：需要 magpie 把 provider 实例 id
+ *   传进来（`plugin-auth.json` 里已经有 `magicrew#p4nwa7` 这种带后缀的 key），
+ *   插件侧拿不到。在那之前这里只能保守。
+ */
+export function accountFor(c, auth) {
+  const direct = accountOf(auth)
+  if (direct !== "default") return direct
+  try {
+    const live = listAccounts(c.id).filter((acc) => storeHasIdentity(c.id, acc))
+    if (live.length === 1) return live[0]
+  } catch {}
+  return direct
+}
+
 /**
  * 拿到这个账号一把能用的 key。**永不抛** —— 续不上就交出手里那把（哪怕不新鲜），
  * 让请求自己去撞上游的错误，比在这里抛更能说明问题。
@@ -50,7 +97,7 @@ export async function ensureKey(c, getAuth, { leadMs } = {}) {
   try {
     auth = typeof getAuth === "function" ? await getAuth() : getAuth
   } catch {}
-  const account = accountOf(auth)
+  const account = accountFor(c, auth)
 
   const st = readStore(c.id, account)
   const cur = currentKey(st)

package/src/vision.mjs

@@ -0,0 +1,193 @@
+// 识图判角度 —— 用 magpie 里**用户自己配的那个识图模型**
+//
+// 为什么需要它：旋转验证的答案只存在于图片里。协议（见 captcha.mjs）能把
+// 「怎么提交」做到位，但「该提交多少度」必须有人看图。
+//
+// 三条实测结论决定了这里怎么写：
+//
+//  ① **不能问「多少度」，要问「主体的上方向指向钟面几点」。**
+//     实测：直接问角度（填空）6 次错 5 次；改成钟点（相对描述）3 轮中 2。
+//     让模型「在脑子里把图转过来」它做不好，问「现在朝哪」它答得稳。
+//
+//  ② **必须问两次并比分歧。**
+//     实测的失败案例是两个判官给出 1.7 和 7.5 钟点（相差 174°）——
+//     其中一个把方向看反了。这种情况取平均毫无意义，只能判为「不可信」重来。
+//
+//  ③ **模型是用户在 magpie 设置里选的那个**（`settings.json` 的 `vision`），
+//     不额外要求他配 key —— magpie 自己就监听着一个 OpenAI 兼容网关，
+//     直接打本地端口就行。
+//
+// ⚠ 模型回什么形状的答案都可能（带解释、带思考过程、结尾才有数字），
+//   所以解析一律「从后往前找最后一个合法数字」，找不到就算这次不可信。
+
+import { readFileSync } from "node:fs"
+import { homedir } from "node:os"
+import { join } from "node:path"
+
+import { CLOCK_MAX_SPREAD, clockSpread, clockToDeg } from "./captcha.mjs"
+
+/** magpie 的配置目录；Windows 上是 ~/.config/magpie，和别的系统一致 */
+export function magpieConfigDir() {
+  return join(homedir(), ".config", "magpie")
+}
+
+/**
+ * 用户选的识图模型。
+ * @returns {string|null} 形如 `workbuddy/deepseek-v4.1-flash`；没配 / 关掉 / 读不到 → null
+ */
+export function readVisionModel() {
+  try {
+    const raw = readFileSync(join(magpieConfigDir(), "settings.json"), "utf8")
+    const j = JSON.parse(raw)
+    const v = String(j?.vision ?? "").trim()
+    if (!v || v === "off" || v === "none" || v === "0") return null
+    return v
+  } catch {
+    return null
+  }
+}
+
+/**
+ * magpie 自己的网关端口。
+ *
+ * 默认 3425（本机实测 `magpie-windows-amd64.exe` 就监听这个）。
+ * 用户能通过 `magpie web --addr host:port` / `magpie serve` 改，所以：
+ *   · 环境变量优先（万一 magpie 把它传进插件进程）
+ *   · 否则按常见端口列表逐个试 —— **只看谁能以 200 回 /v1/models**
+ */
+export function gatewayCandidates() {
+  const fromEnv = [process.env.MAGPIE_GATEWAY_PORT, process.env.MAGPIE_PORT]
+    .map((x) => Number(x))
+    .filter((n) => Number.isFinite(n) && n > 0)
+  const common = [3425, 3426, 8080]
+  return [...new Set([...fromEnv, ...common])]
+}
+
+let cachedBase = null
+
+/** 探一个能用的网关基址；找到就记住，找不到返回 null */
+export async function resolveGatewayBase() {
+  if (cachedBase) return cachedBase
+  for (const port of gatewayCandidates()) {
+    const base = `http://127.0.0.1:${port}/v1`
+    try {
+      const res = await fetch(`${base}/models`, { signal: AbortSignal.timeout(1500) })
+      if (res.ok) {
+        cachedBase = base
+        return base
+      }
+    } catch {
+      /* 这个端口没在听，试下一个 */
+    }
+  }
+  return null
+}
+
+/**
+ * webp → png 的 data URL。
+ *
+ * 为什么要转：验证码图是 `data:image/webp`，不是每个视觉模型都吃 webp。
+ * magpie 自带的 bun 有 `Bun.Image`（实测能解 webp），在没有它的环境里就原样返回。
+ */
+export async function toPngDataUrl(imageDataUrl) {
+  if (!/^data:image\/webp/i.test(imageDataUrl)) return imageDataUrl
+  try {
+    if (typeof Bun === "undefined" || typeof Bun.Image !== "function") return imageDataUrl
+    const b64 = imageDataUrl.split(",")[1] || ""
+    const img = new Bun.Image(Buffer.from(b64, "base64"))
+    await img.metadata()
+    img.png()
+    const out = await img.toBuffer()
+    return "data:image/png;base64," + Buffer.from(out).toString("base64")
+  } catch {
+    return imageDataUrl
+  }
+}
+
+const CLOCK_PROMPT = (variant) => {
+  const frame =
+    variant === 0
+      ? "想象一个钟面盖在图上：12 = 正上方，3 = 正右方，6 = 正下方，9 = 正左方。"
+      : "把这张图当成表盘：最上方是 12 点，顺时针数到 3 点在右、6 点在正下、9 点在左。"
+  return `这张图片被随机旋转过，是圆形裁切的照片，里面有一个主体。
+${frame}
+判断：主体自己的"上方向"（人的头顶、动物的头顶、瓶子口、相机顶部那一侧）现在指向钟面的几点？
+要精确，允许一位小数（例如 7.3）。
+最后一行只输出这个数字，不要写别的。`
+}
+
+/** 从一段话里取「最后出现的、落在 0…12 的数」—— 模型常在前面铺垫一堆 */
+function lastClock(text) {
+  const nums = String(text || "").match(/\d+(?:\.\d+)?/g)
+  if (!nums) return null
+  for (let i = nums.length - 1; i >= 0; i--) {
+    const v = Number(nums[i])
+    if (Number.isFinite(v) && v >= 0 && v <= 12) return v
+  }
+  return null
+}
+
+async function askClock(base, model, imageDataUrl, variant) {
+  const res = await fetch(`${base}/chat/completions`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    // temperature 0 是为了同一张图两次问法之外的噪声尽量小；
+    // 两次用不同措辞（variant）而不是靠随机温度，好复现
+    body: JSON.stringify({
+      model,
+      max_tokens: 400,
+      temperature: 0,
+      messages: [
+        {
+          role: "user",
+          content: [
+            { type: "text", text: CLOCK_PROMPT(variant) },
+            { type: "image_url", image_url: { url: imageDataUrl } },
+          ],
+        },
+      ],
+    }),
+    signal: AbortSignal.timeout(45_000),
+  })
+  if (!res.ok) throw new Error(`识图模型回 HTTP ${res.status}`)
+  const j = await res.json()
+  const text = j?.choices?.[0]?.message?.content ?? ""
+  return { clock: lastClock(text), text: String(text).trim().slice(0, 200) }
+}
+
+/**
+ * 让识图模型判断「该顺时针转多少度」。
+ *
+ * @returns {Promise<{ok:true, deg:number, clock:number, spread:number, model:string}
+ *                  |{ok:false, reason:string, detail?:string}>}
+ */
+export async function decideDegFromImage(imageDataUrl) {
+  const model = readVisionModel()
+  if (!model) return { ok: false, reason: "no-vision-model" }
+
+  const base = await resolveGatewayBase()
+  if (!base) return { ok: false, reason: "no-gateway", detail: "连不上 magpie 自己的网关（试过 3425/3426/8080）" }
+
+  const img = await toPngDataUrl(imageDataUrl)
+  const a = await askClock(base, model, img, 0).catch((e) => ({ clock: null, text: String(e?.message ?? e) }))
+  const b = await askClock(base, model, img, 1).catch(() => ({ clock: null, text: "" }))
+
+  if (a.clock == null && b.clock == null) {
+    return { ok: false, reason: "unparsable", detail: `${a.text} / ${b.text}` }
+  }
+  // 只拿到一个也能用（另一个多半是被截断或跑题了）
+  if (a.clock == null || b.clock == null) {
+    const one = a.clock ?? b.clock
+    return { ok: true, deg: clockToDeg(one), clock: one, spread: 0, model, single: true }
+  }
+
+  const spread = clockSpread(a.clock, b.clock)
+  if (spread > CLOCK_MAX_SPREAD) {
+    // 相差超过 1.5 钟点（45°）基本就是「有一个人把方向看反了」，
+    // 这时候取平均只会得到一个两边都不对的中间值 —— 宁可换一张图重来
+    return { ok: false, reason: "disagree", detail: `${a.clock} vs ${b.clock}（相差 ${spread.toFixed(1)} 钟点）`, spread }
+  }
+
+  const clock = (a.clock + b.clock) / 2
+  return { ok: true, deg: clockToDeg(clock), clock, spread, model }
+}