opencode-lobster-auth 0.1.1 → 0.2.0

package/index.mjs

@@ -1,191 +1,226 @@
-import { PROVIDER, NAME, API, CHAT_BASE, NPM, FALLBACK_MODELS } from "./lib/constants.mjs"
-import { makeFetch } from "./lib/proxy.mjs"
-import { modelsFromCatalog, profileOfFrom } from "./lib/models.mjs"
-import { usageFrom } from "./lib/usage.mjs"
-import { desktopSignIn, desktopToken } from "./lib/auth-import.mjs"
-import { beginSignIn } from "./lib/auth-login.mjs"
-import { jwtExp } from "./lib/jwt.mjs"
-
-const REFRESH_LEAD = 6 * 3600 * 1000
-
-// 每个账号的模型 → 思考档位，供请求管线查表
-const profiles = new Map()
-
-async function apiGet(path, token, timeout = 20_000) {
-  const res = await fetch(API + path, {
-    headers: { authorization: `Bearer ${token}` },
-    signal: AbortSignal.timeout(timeout),
-  })
-  const text = await res.text()
-  let v
-  try { v = JSON.parse(text) } catch { throw new Error(`LobsterAI ${path}: 响应无法解析`) }
-  if (res.status === 401) {
-    throw Object.assign(new Error("LobsterAI 的登录已过期，请重新登录"), { signIn: "expired" })
-  }
-  if (v?.code !== 0) throw new Error(`LobsterAI ${path}: ${v?.message || `code ${v?.code}`}`)
-  return v.data
-}
-
-// 取这次请求要用的 token。
-// 桌面端导入的账号自己不存 token（见 lib/auth-import.mjs），每次现读 ——
-// 桌面端续期后插件自动跟上。读不到就抛 signIn:"expired"。
-async function tokenOf(auth) {
-  if (!auth) return ""
-  if (auth.source === "desktop") return desktopToken()
-  return auth.type === "oauth" ? (auth.access ?? "") : (auth.key ?? "")
-}
-
-export const LobsterAuthPlugin = async () => ({
-  config: async (cfg) => {
-    cfg.provider ??= {}
-    cfg.provider[PROVIDER] ??= {
-      name: NAME,
-      npm: NPM,
-      api: API,
-      models: FALLBACK_MODELS,
-    }
-  },
-
-  auth: {
-    provider: PROVIDER,
-    refreshLead: REFRESH_LEAD,
-
-    methods: [
-      {
-        type: "oauth",
-        label: "浏览器登录（有道账号）",
-        async authorize() {
-          // 由 magpie 打开这个 url；插件不再自己开一次，否则会开两个标签页
-          const pending = await beginSignIn()
-          return {
-            url: pending.url,
-            instructions: "在浏览器里用有道账号登录，完成后回到这里。",
-            method: "auto",
-            callback: () => pending.finish(),
-          }
-        },
-      },
-      {
-        // 必须是 oauth：api 类型会让 magpie 强制从 stdin 读一个 key，
-        // 而这条路根本不需要用户输入任何东西（见设计文档 §4.3）。
-        type: "oauth",
-        label: "从本机 LobsterAI 导入登录",
-        async authorize() {
-          // url 留空：magpie 不打开任何页面，直接走 callback
-          return {
-            url: "",
-            instructions: "直接使用本机 LobsterAI 桌面端已登录的账号。",
-            method: "auto",
-            async callback() {
-              try {
-                return desktopSignIn()
-              } catch (e) {
-                return { type: "failed", error: e.message }
-              }
-            },
-          }
-        },
-      },
-    ],
-
-    // 只对路径 A（浏览器登录，有 refresh 和 expires）生效。
-    // 路径 B（桌面端导入）的 refresh 是空串、expires 为 0，
-    // magpie 不会调用这里，桌面端的会话因此不会被搅动。
-    async refresh(auth) {
-      if (auth?.type !== "oauth" || auth.source === "desktop" || !auth.refresh) return {}
-      const res = await fetch(`${API}/auth/refresh`, {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ refreshToken: auth.refresh }),
-        signal: AbortSignal.timeout(30_000),
-      })
-      const text = await res.text()
-      let v
-      try { v = JSON.parse(text) } catch { throw new Error("LobsterAI 续期：响应无法解析") }
-      if (v?.code !== 0 || !v?.data?.accessToken) {
-        throw Object.assign(new Error(`LobsterAI 续期失败：${v?.message || `code ${v?.code}`}`), { signIn: "expired" })
-      }
-      const d = v.data
-      return {
-        access: String(d.accessToken),
-        refresh: String(d.refreshToken ?? auth.refresh),
-        // 上游可能不给新 token 的 exp；读不到就沿用旧的到期时间
-        expires: jwtExp(d.accessToken) || auth.expires || 0,
-      }
-    },
-
-    async loader(getAuth) {
-      const auth = await getAuth()
-      // 这里只是给 magpie 一个「看起来已登录」的信号；真正的 token
-      // 由下面的 fetch 每次请求现取（桌面端账号尤其需要）。
-      let token = ""
-      try { token = await tokenOf(auth) } catch { return {} }
-      if (!token) return {}
-      return {
-        baseURL: CHAT_BASE,
-        apiKey: token,
-        headers: {},
-        fetch: makeFetch({
-          getAuth,
-          tokenOf,
-          profileOf: (id) => profiles.get(String(id)),
-          call: (input, init) => fetch(input, init),
-        }),
-      }
-    },
-
-    async usage(getAuth) {
-      const auth = await getAuth()
-      let token = ""
-      try { token = await tokenOf(auth) } catch (e) {
-        return { error: e.message, windows: [], signIn: e.signIn === "expired" ? "expired" : "kept" }
-      }
-      if (!token) return { error: "尚未登录", windows: [] }
-      try {
-        const [quota, profile] = await Promise.all([
-          apiGet("/user/quota", token),
-          apiGet("/user/profile-summary", token),
-        ])
-        // 插件自己不续期（交给 magpie 的 auth.refresh），所以这次请求用的
-        // 就是存下来的 token —— 如实报 kept。社区插件报 renewed 是因为它们
-        // 自己维护续期表，这里没有那张表，不该照抄。
-        return usageFrom(quota, profile, "kept")
-      } catch (e) {
-        return {
-          error: e.message,
-          windows: [],
-          signIn: e.signIn === "expired" ? "expired" : "kept",
-        }
-      }
-    },
-  },
-
-  provider: {
-    id: PROVIDER,
-    async models(provider, { auth } = {}) {
-      let token = ""
-      try { token = await tokenOf(auth) } catch (e) {
-        if (e.signIn === "expired") throw e
-        return provider.models
-      }
-      if (!token) return provider.models
-      try {
-        const list = await apiGet(
-          "/models/available?firstKeyfrom=official&latestKeyfrom=official",
-          token,
-        )
-        if (!Array.isArray(list) || list.length === 0) return provider.models
-        for (const [id, p] of Object.entries(profileOfFrom(list))) profiles.set(id, p)
-        const out = modelsFromCatalog(list, { ...provider, id: PROVIDER })
-        return Object.keys(out).length > 0 ? out : provider.models
-      } catch (e) {
-        // 登录失效要标记账号；其余情况保留原列表
-        if (e.signIn === "expired") throw e
-        return provider.models
-      }
-    },
-  },
-})
-
-// 唯一允许的函数导出：magpie 会把每个导出的函数都当成一个插件加载
-export const _internal = { PROVIDER, FALLBACK_MODELS, usageFrom, modelsFromCatalog }
+import { PROVIDER, NAME, API, CHAT_BASE, NPM, FALLBACK_MODELS } from "./lib/constants.mjs"
+import { makeFetch } from "./lib/proxy.mjs"
+import { modelsFromCatalog, profileOfFrom } from "./lib/models.mjs"
+import { usageFrom } from "./lib/usage.mjs"
+import { desktopSignIn, desktopToken } from "./lib/auth-import.mjs"
+import { beginSignIn, beginSignInAnnounced } from "./lib/auth-login.mjs"
+import { checkinWith } from "./lib/checkin.mjs"
+import { jwtExp } from "./lib/jwt.mjs"
+
+const REFRESH_LEAD = 6 * 3600 * 1000
+
+// 每个账号的模型 → 思考档位，供请求管线查表
+const profiles = new Map()
+
+async function apiGet(path, token, timeout = 20_000) {
+  const res = await fetch(API + path, {
+    headers: { authorization: `Bearer ${token}` },
+    signal: AbortSignal.timeout(timeout),
+  })
+  const text = await res.text()
+  let v
+  try { v = JSON.parse(text) } catch { throw new Error(`LobsterAI ${path}: 响应无法解析`) }
+  if (res.status === 401) {
+    throw Object.assign(new Error("LobsterAI 的登录已过期，请重新登录"), { signIn: "expired" })
+  }
+  if (v?.code !== 0) throw new Error(`LobsterAI ${path}: ${v?.message || `code ${v?.code}`}`)
+  return v.data
+}
+
+// 取这次请求要用的 token。
+// 桌面端导入的账号自己不存 token（见 lib/auth-import.mjs），每次现读 ——
+// 桌面端续期后插件自动跟上。读不到、或桌面端已经换成别的账号，都抛
+// signIn:"expired"（多账号时后者防止串号）。
+async function tokenOf(auth) {
+  if (!auth) return ""
+  if (auth.source === "desktop") return desktopToken(process.env, auth.accountId, auth.uid)
+  return auth.type === "oauth" ? (auth.access ?? "") : (auth.key ?? "")
+}
+
+export const LobsterAuthPlugin = async () => ({
+  config: async (cfg) => {
+    cfg.provider ??= {}
+    cfg.provider[PROVIDER] ??= {
+      name: NAME,
+      npm: NPM,
+      api: API,
+      models: FALLBACK_MODELS,
+    }
+  },
+
+  auth: {
+    provider: PROVIDER,
+    refreshLead: REFRESH_LEAD,
+
+    methods: [
+      {
+        type: "oauth",
+        label: "浏览器登录（有道账号）",
+        async authorize() {
+          // 由 magpie 打开这个 url；插件不再自己开一次，否则会开两个标签页
+          const pending = await beginSignIn()
+          return {
+            url: pending.url,
+            instructions: "在浏览器里用有道账号登录，完成后回到这里。",
+            method: "auto",
+            callback: () => pending.finish(),
+          }
+        },
+      },
+      {
+        // 浏览器在另一台机器上（magpie 跑在 NAS / Docker 里，用这台电脑的
+        // 浏览器打开它的页面）：回调落在浏览器的 127.0.0.1，到不了 magpie。
+        // 登录地址在普通 query 里写明了本机回调端口，magpie 因此会为这次
+        // 登录显示「回调 URL」输入框；把登录后地址栏里的完整地址粘进去，
+        // magpie 在本机把请求送到插件正在监听的端口，回调照常抵达，
+        // 剩下的与「浏览器登录」完全一样。
+        type: "oauth",
+        label: "远程浏览器登录",
+        async authorize() {
+          const pending = await beginSignInAnnounced()
+          return {
+            url: pending.url,
+            instructions: "在浏览器里用有道账号登录。登录后浏览器会跳到 127.0.0.1 并提示无法访问，这是预期现象：复制此时地址栏的完整地址，粘贴到下面的「回调 URL」，再点「完成登录」。请在 5 分钟内完成；回调地址包含一次性授权信息，不要发给别人。",
+            method: "auto",
+            callback: () => pending.finish(),
+          }
+        },
+      },
+      {
+        // 必须是 oauth：api 类型会让 magpie 强制从 stdin 读一个 key，
+        // 而这条路根本不需要用户输入任何东西（见设计文档 §4.3）。
+        type: "oauth",
+        label: "从本机 LobsterAI 导入登录",
+        async authorize() {
+          // url 留空：magpie 不打开任何页面，直接走 callback
+          return {
+            url: "",
+            instructions: "直接使用本机 LobsterAI 桌面端已登录的账号。",
+            method: "auto",
+            async callback() {
+              try {
+                return desktopSignIn()
+              } catch (e) {
+                return { type: "failed", error: e.message }
+              }
+            },
+          }
+        },
+      },
+    ],
+
+    // 只对路径 A（浏览器登录，有 refresh 和 expires）生效。
+    // 路径 B（桌面端导入）的 refresh 是空串、expires 为 0，
+    // magpie 不会调用这里，桌面端的会话因此不会被搅动。
+    async refresh(auth) {
+      if (auth?.type !== "oauth" || auth.source === "desktop" || !auth.refresh) return {}
+      const res = await fetch(`${API}/auth/refresh`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ refreshToken: auth.refresh }),
+        signal: AbortSignal.timeout(30_000),
+      })
+      const text = await res.text()
+      let v
+      try { v = JSON.parse(text) } catch { throw new Error("LobsterAI 续期：响应无法解析") }
+      if (v?.code !== 0 || !v?.data?.accessToken) {
+        throw Object.assign(new Error(`LobsterAI 续期失败：${v?.message || `code ${v?.code}`}`), { signIn: "expired" })
+      }
+      const d = v.data
+      return {
+        access: String(d.accessToken),
+        refresh: String(d.refreshToken ?? auth.refresh),
+        // 上游可能不给新 token 的 exp；读不到就沿用旧的到期时间
+        expires: jwtExp(d.accessToken) || auth.expires || 0,
+      }
+    },
+
+    async loader(getAuth) {
+      const auth = await getAuth()
+      // 这里只是给 magpie 一个「看起来已登录」的信号；真正的 token
+      // 由下面的 fetch 每次请求现取（桌面端账号尤其需要）。
+      let token = ""
+      try { token = await tokenOf(auth) } catch { return {} }
+      if (!token) return {}
+      return {
+        baseURL: CHAT_BASE,
+        apiKey: token,
+        headers: {},
+        fetch: makeFetch({
+          getAuth,
+          tokenOf,
+          profileOf: (id) => profiles.get(String(id)),
+          call: (input, init) => fetch(input, init),
+        }),
+      }
+    },
+
+    async usage(getAuth) {
+      const auth = await getAuth()
+      let token = ""
+      try { token = await tokenOf(auth) } catch (e) {
+        return { error: e.message, windows: [], signIn: e.signIn === "expired" ? "expired" : "kept" }
+      }
+      if (!token) return { error: "尚未登录", windows: [] }
+      try {
+        const [quota, profile] = await Promise.all([
+          apiGet("/user/quota", token),
+          apiGet("/user/profile-summary", token),
+        ])
+        // 插件自己不续期（交给 magpie 的 auth.refresh），所以这次请求用的
+        // 就是存下来的 token —— 如实报 kept。社区插件报 renewed 是因为它们
+        // 自己维护续期表，这里没有那张表，不该照抄。
+        return usageFrom(quota, profile, "kept")
+      } catch (e) {
+        return {
+          error: e.message,
+          windows: [],
+          signIn: e.signIn === "expired" ? "expired" : "kept",
+        }
+      }
+    },
+
+    // 每日积分礼（签到）。magpie 在开关打开后，对每个已登录账号每天各调一次。
+    // 这是写操作，开关默认关，由用户在 Settings → Usage → Plugins 打开。
+    // 逻辑见 lib/checkin.mjs；这里只负责取 token 和兜住异常。
+    async checkin(getAuth) {
+      const auth = await getAuth()
+      let token = ""
+      try {
+        token = await tokenOf(auth)
+      } catch (e) {
+        return { outcome: "failed", message: e.message }
+      }
+      return checkinWith(token)
+    },
+  },
+
+  provider: {
+    id: PROVIDER,
+    async models(provider, { auth } = {}) {
+      let token = ""
+      try { token = await tokenOf(auth) } catch (e) {
+        if (e.signIn === "expired") throw e
+        return provider.models
+      }
+      if (!token) return provider.models
+      try {
+        const list = await apiGet(
+          "/models/available?firstKeyfrom=official&latestKeyfrom=official",
+          token,
+        )
+        if (!Array.isArray(list) || list.length === 0) return provider.models
+        for (const [id, p] of Object.entries(profileOfFrom(list))) profiles.set(id, p)
+        const out = modelsFromCatalog(list, { ...provider, id: PROVIDER })
+        return Object.keys(out).length > 0 ? out : provider.models
+      } catch (e) {
+        // 登录失效要标记账号；其余情况保留原列表
+        if (e.signIn === "expired") throw e
+        return provider.models
+      }
+    },
+  },
+})
+
+// 唯一允许的函数导出：magpie 会把每个导出的函数都当成一个插件加载
+export const _internal = { PROVIDER, FALLBACK_MODELS, usageFrom, modelsFromCatalog }

package/lib/assemble.mjs

@@ -2,6 +2,8 @@
 // 流式请求原样转发；非流式请求要把分片拼成一个完整的 chat.completion。
 
 import { randomBytes } from "node:crypto"
+import { errorFrame, StreamError } from "./stream-error.mjs"
+export { StreamError } from "./stream-error.mjs"
 
 const enc = new TextEncoder()
 
@@ -23,6 +25,8 @@ export async function mergeChunks(records, model) {
   let reasoning = ""
 
   for await (const rec of records) {
+    const bad = errorFrame(rec)
+    if (bad) throw new StreamError(bad)
     if (rec.data === "[DONE]") break
     let v
     try { v = JSON.parse(rec.data) } catch { continue }
@@ -61,7 +65,9 @@ function streamOut(records) {
       try {
         for await (const rec of records) {
           if (rec.data === "[DONE]") break
-          controller.enqueue(enc.encode(`data: ${rec.data}\n\n`))
+          const event = rec.event ? `event: ${rec.event}\n` : ""
+          const data = rec.data.split("\n").map((line) => `data: ${line}`).join("\n")
+          controller.enqueue(enc.encode(`${event}${data}\n\n`))
         }
         controller.enqueue(enc.encode("data: [DONE]\n\n"))
         controller.close()

package/lib/auth-import.mjs

@@ -30,6 +30,12 @@ const parse = (s) => {
   } catch { return null }
 }
 
+const identityValue = (value) => {
+  if (typeof value === "string") return value.trim() || undefined
+  if (typeof value === "number" && Number.isFinite(value)) return String(value)
+  return undefined
+}
+
 export function readCredentials(path) {
   if (!path || !existsSync(path)) return null
   let db
@@ -43,11 +49,18 @@ export function readCredentials(path) {
     if (!accessToken) return null
     const user = parse(byKey.auth_user) ?? {}
     const claims = accountOf(accessToken)
+    // 两行可能分开更新。身份必须来自实际使用的 token；用户行只能在已有
+    // 共同标识吻合、且没有任何冲突时补全字段，不能让旧用户行替新 token 作证。
+    const fields = ["yid", "id"]
+    const shared = fields.filter((key) => identityValue(claims[key]) !== undefined && identityValue(user[key]) !== undefined)
+    const identityConflict = shared.some((key) => identityValue(claims[key]) !== identityValue(user[key]))
+    const verifiedUser = shared.length > 0 && !identityConflict
     return {
       accessToken,
       refreshToken: String(tokens?.refreshToken ?? ""),
-      yid: user.yid ?? claims.yid,
-      id: user.id ?? claims.id,
+      yid: identityValue(claims.yid) !== undefined ? claims.yid : verifiedUser ? user.yid : undefined,
+      id: identityValue(claims.id) !== undefined ? claims.id : verifiedUser ? user.id : undefined,
+      identityConflict,
       nickname: user.nickname,
       expires: jwtExp(accessToken),
     }
@@ -65,6 +78,24 @@ export function readCredentials(path) {
 // 为什么不把 token 抄一份：抄下来的 refreshToken 会是桌面端和插件共用的，
 // 谁先续期谁就把对方踢下线。留空则 magpie 永不续期（expires 为 0），
 // 桌面端的会话不受任何影响。
+// 账号身份。magpie 支持一个插件挂多个账号，靠 accountId 区分，所以这个值
+// 既是「这个号叫什么」，也是下次读桌面端时核对「还是不是同一个号」的依据。
+// 优先用 yid（有道的账号标识），没有就退回数字 id 的字符串形式。
+// yid 一律转成字符串：magpie 往返一轮后回来的是字符串，留着数字会让
+// 同一个号在两侧比不相等，把好账号误判成「切换了账号」。
+export function accountIdOf(c) {
+  return identityValue(c?.yid) ?? identityValue(c?.id)
+}
+
+function requireIdentity(c) {
+  if (c.identityConflict) {
+    throw Object.assign(new Error("LobsterAI 桌面端 token 与账号身份不一致（可能正在切换账号），请稍后重新登录"), { signIn: "expired" })
+  }
+  if (!accountIdOf(c)) {
+    throw Object.assign(new Error("LobsterAI 桌面端 token 的账号身份不可读，请重新登录本账号"), { signIn: "expired" })
+  }
+}
+
 export function desktopSignIn(env = process.env) {
   const path = dbPath(env)
   const c = readCredentials(path)
@@ -74,21 +105,31 @@ export function desktopSignIn(env = process.env) {
       "请先在 LobsterAI 桌面端登录，或改用「浏览器登录」。",
     )
   }
+  requireIdentity(c)
   return {
     type: "success",
     refresh: "",
     access: "",
     expires: 0,
     source: "desktop",
-    accountId: c.yid ?? (c.id !== undefined ? String(c.id) : undefined),
-    uid: c.id,
+    accountId: accountIdOf(c),
+    // magpie 只认字符串 uid（源码 uidOf），存数字等于没存
+    uid: identityValue(c.id),
   }
 }
 
 // 桌面端账号的 token：每次现读，桌面端换了 token 插件立刻跟上。
 // 读不到就是账号不可用（桌面端退出登录、库被删、文件被加密），
 // 报 signIn:"expired" 让 magpie 给账号打上失效标记，提示用户重新登录。
-export function desktopToken(env = process.env) {
+//
+// expected 是这个账号签入时记下的身份，expectedUid 是当时记下的数字 id。
+// 桌面端只有一个「当前登录」，换账号后现读到的就是别人的 token —— 不核对的话，
+// 原账号会显示别人的余额、扣别人的积分、签到签在别人头上。
+//
+// 至少一个绑定标识要匹配，同时不能有其它可比较标识冲突。签入时只有数字 id、
+// 后来补上 yid 的情况仍可按 id 识别；但 uid 相同不能掩盖已绑定 yid 的变化。
+// 没保存绑定身份的老账号仍兼容；token 无身份或与用户行冲突时一律 fail-closed。
+export function desktopToken(env = process.env, expected, expectedUid) {
   const c = readCredentials(dbPath(env))
   if (!c) {
     throw Object.assign(
@@ -96,5 +137,29 @@ export function desktopToken(env = process.env) {
       { signIn: "expired" },
     )
   }
+  requireIdentity(c)
+  const account = identityValue(expected)
+  const uid = identityValue(expectedUid)
+  if (account === undefined && uid === undefined) return c.accessToken
+  const now = accountIdOf(c)
+  const currentYid = identityValue(c.yid)
+  const currentUid = identityValue(c.id)
+  const accountWasUid = account !== undefined && (account === uid || account === currentUid)
+  const conflict =
+    (uid !== undefined && currentUid !== undefined && uid !== currentUid) ||
+    (account !== undefined && currentYid !== undefined && account !== currentYid && !accountWasUid)
+  const sameAccount =
+    (account !== undefined && (account === now || account === currentUid)) ||
+    (uid !== undefined && uid === currentUid)
+  if (conflict || !sameAccount) {
+    throw Object.assign(
+      new Error(
+        now
+          ? `LobsterAI 桌面端已切换到其它账号（当前 ${now}，本账号 ${expected}），请重新登录本账号`
+          : "LobsterAI 桌面端当前登录的账号身份不可读（可能刚切换过），请确认后在桌面端重新登录本账号",
+      ),
+      { signIn: "expired" },
+    )
+  }
   return c.accessToken
 }