@magpie-community/opencode-qoder-auth 0.1.2 → 0.1.4

package/index.mjs

@@ -16,6 +16,7 @@
 // from magpie's internal/qoder, which ported it from CLIProxyAPI's qoder
 // support (https://github.com/ufec/CLIProxyAPI, MIT).
 import { createCipheriv, createHash, publicEncrypt, randomBytes, randomUUID, constants } from "node:crypto"
+import { STATUS_CODES } from "node:http"
 
 const ID = "qoder"
 const CLIENT_ID = "732aef47-9cf2-46a2-95fe-4cebb5d0d1fa"
@@ -213,17 +214,27 @@ async function deviceSignIn() {
   }
 }
 
-class SignInGone extends Error {}
+// SignInGone is a sign-in that can't sign a request: a 401. Only Qoder
+// refusing the refresh token marks the account lapsed (expired), as the
+// built-in's qoderRefreshFailed did; no refresh token, or no account,
+// answered 401 there without marking one.
+class SignInGone extends Error {
+  constructor(message, expired = false) {
+    super(message)
+    this.expired = expired
+  }
+}
 
 // refreshJob trades the job token's refresh token for a new pair; the old
 // one is spent.
-async function refreshJob(refresh) {
+async function refreshJob(refresh, user) {
   if (!String(refresh ?? "").trim()) throw new SignInGone("Qoder: the sign-in lapsed; sign in again")
   const r = await openapi("/api/v1/jobToken/refresh", { method: "POST", body: { refresh_token: refresh } })
-  if (r.status === 401 || r.status === 403) throw new SignInGone("Qoder: the sign-in has expired — sign in again")
-  if (r.status !== 200) throw new Error(`Qoder job token refresh: status ${r.status}`)
+  if (r.status === 401 || r.status === 403)
+    throw new SignInGone(`${user}'s Qoder sign-in has expired — sign in again (qoder job token refresh: status ${r.status})`, true)
+  if (r.status !== 200) throw new Error(`qoder job token refresh: status ${r.status}`)
   if (!String(r.json?.token ?? "").trim() || !String(r.json?.refresh_token ?? "").trim())
-    throw new Error("Qoder job token refresh: incomplete token pair")
+    throw new Error("qoder job token refresh: incomplete token pair")
   return r.json
 }
 
@@ -486,19 +497,26 @@ function failure(status, text) {
   try {
     const j = JSON.parse(text)
     if (j?.message) msg = j.message
-    const d = typeof j?.details === "string" ? JSON.parse(j.details) : null
+    // details is a JSON string, or the object itself (gjson reads either)
+    const d = typeof j?.details === "string" ? JSON.parse(j.details) : j?.details
     if (d?.error?.message) msg += ": " + d.error.message
   } catch {}
-  msg ||= `HTTP ${status}`
-  // only Qoder's 401 says the job token itself is refused; a 403 is kept as
-  // what it is, as magpie marks the account lapsed on a 401
-  if (status === 401 || status === 403) return { status, message: "the sign-in lapsed — sign in again" }
+  msg ||= STATUS_CODES[status] ?? `HTTP ${status}`
+  // a refused chat is the built-in's 401, which never marked the account
+  // lapsed: only a refused refresh did (errorResponse says kept)
+  if (status === 401 || status === 403) return { status: 401, message: "the sign-in lapsed — sign in again" }
   if (status === 429 || msg.toLowerCase().includes("quota")) return { status: 429, message: "usage limit reached: " + msg }
   return { status, message: msg }
 }
 
-const errorResponse = ({ status, message }) =>
-  new Response(JSON.stringify({ error: { message, type: "qoder_error", code: status } }), { status, headers: { "Content-Type": "application/json" } })
+// errorResponse is a failure as OpenAI's API gives it. signIn is what it
+// means for the account (magpie's X-Magpie-Sign-In): a 401 keeps it unless
+// told expired, since the built-in marked only a refused refresh.
+const errorResponse = ({ status, message, signIn = status === 401 ? "kept" : undefined }) =>
+  new Response(JSON.stringify({ error: { message, type: "qoder_error", code: status } }), {
+    status,
+    headers: { "Content-Type": "application/json", ...(signIn ? { "X-Magpie-Sign-In": signIn } : {}) },
+  })
 
 // ---- the reply ----------------------------------------------------------------
 
@@ -741,6 +759,17 @@ async function bodyText(input, init) {
   return typeof b === "string" ? b : new TextDecoder().decode(b)
 }
 
+// signed is res saying what it means for the sign-in, as the built-in's
+// answer did: a renewed job token cleared the mark whatever came of the
+// request; without one, a success left the mark as it was.
+function signed(res, renewed) {
+  const said = renewed ? "renewed" : res.ok ? "kept" : null
+  if (!said) return res
+  const headers = new Headers(res.headers)
+  headers.set("X-Magpie-Sign-In", said)
+  return new Response(res.body, { status: res.status, statusText: res.statusText, headers })
+}
+
 // ---- usage --------------------------------------------------------------------
 //
 // The account's allowance as magpie's built-in Qoder account shows it
@@ -862,6 +891,17 @@ export async function QoderAuthPlugin({ client }) {
   }
   // each account's listing, the model configs a request carries
   const listings = new Map()
+  // the accounts fresh renewed: the built-in took the lapse mark off on a
+  // renewed job token (qoderPersist), whatever the request then met
+  const renewals = new WeakSet()
+  // the accounts the models hook renewed: that hook has no way to say so
+  // and still answer the list, so the account's next usage read or answer
+  // says "renewed" for it
+  const unsaid = new Set()
+  const renewed = (cred) => {
+    const was = unsaid.delete(cred.uid)
+    return renewals.has(cred) || was
+  }
 
   // fresh is the account with a live job token, refreshed and saved near
   // its end.
@@ -870,9 +910,10 @@ export async function QoderAuthPlugin({ client }) {
       const a = await getAuth()
       if (a?.type !== "oauth" || !a.access || !a.uid) throw new SignInGone("Qoder: not signed in")
       if (a.expires - Date.now() > REFRESH_LEAD) return a
-      const jt = await refreshJob(a.refresh)
+      const jt = await refreshJob(a.refresh, a.accountId || a.email || a.uid)
       const next = { ...a, access: jt.token, refresh: jt.refresh_token, expires: expiresAt(jt) }
       await client.auth.set({ path: { id: ID }, body: next })
+      renewals.add(next)
       return next
     })
 
@@ -896,10 +937,15 @@ export async function QoderAuthPlugin({ client }) {
       return dt.token
     })
 
-  // usage is the account's allowance, magpie's own hook
+  // usage is the account's allowance, magpie's own hook. signIn is what the read means for the sign-in, as the built-in's did:
+  // a refused job refresh marks it, a renewed one clears it, and nothing
+  // else does — not a clean read, nor a refused device token, which serves
+  // only the account pages
   const usage = async (getAuth) => {
+    let signIn = "kept"
     try {
       const cred = await fresh(getAuth)
+      if (renewed(cred)) signIn = "renewed"
       let env
       try {
         env = await fetchUsage(cred.deviceToken)
@@ -907,14 +953,47 @@ export async function QoderAuthPlugin({ client }) {
         if (!(e instanceof UsageStatus) || (e.status !== 401 && e.status !== 403)) throw e
         env = await fetchUsage(await deviceToken(getAuth, cred.deviceToken))
       }
-      return parseUsage(env)
+      return { ...parseUsage(env), signIn }
     } catch (e) {
-      return { error: e?.message ?? String(e) }
+      return { error: e?.message ?? String(e), signIn: e?.expired ? "expired" : signIn }
     }
   }
 
   const signedInError = (e) =>
-    errorResponse({ status: e instanceof SignInGone ? 401 : 502, message: String(e?.message ?? e).replace(/^Qoder: /, "") })
+    errorResponse({
+      status: e instanceof SignInGone ? 401 : 502,
+      message: String(e?.message ?? e).replace(/^Qoder: /, ""),
+      signIn: e?.expired ? "expired" : undefined,
+    })
+
+  // ask is the answer to a chat completion on the live account cred.
+  const ask = async (chat, cred, init) => {
+    let m
+    try {
+      m = (await models(cred)).find((x) => x.key === chat.model) ?? (await models(cred, true)).find((x) => x.key === chat.model)
+    } catch (e) {
+      // the built-in answered any failure to read the list 400
+      // (QoderModelOf), a refused one included, marking nothing
+      return errorResponse({ status: 400, message: e.message })
+    }
+    if (!m) return errorResponse({ status: 400, message: `unknown or disabled model "${chat.model}"` })
+    const wire = encodeBody(JSON.stringify(qoderBody(chat, m)))
+    const headers = {
+      ...cosyHeaders(CHAT_URL, cred, wire),
+      Accept: "text/event-stream",
+      "Cache-Control": "no-cache",
+      "X-Model-Key": m.key,
+      "X-Model-Source": m.source,
+    }
+    let res
+    try {
+      res = await fetch(CHAT_URL, { method: "POST", headers, body: wire, signal: init.signal })
+    } catch (e) {
+      return errorResponse({ status: 502, message: e.message })
+    }
+    if (!res.ok) return errorResponse(failure(res.status, (await res.text()).slice(0, 1 << 20)))
+    return answer(res, chat)
+  }
 
   return {
     auth: {
@@ -942,29 +1021,7 @@ export async function QoderAuthPlugin({ client }) {
             } catch (e) {
               return signedInError(e)
             }
-            let m
-            try {
-              m = (await models(cred)).find((x) => x.key === chat.model) ?? (await models(cred, true)).find((x) => x.key === chat.model)
-            } catch (e) {
-              return errorResponse({ status: 502, message: e.message })
-            }
-            if (!m) return errorResponse({ status: 400, message: `unknown or disabled model "${chat.model}"` })
-            const wire = encodeBody(JSON.stringify(qoderBody(chat, m)))
-            const headers = {
-              ...cosyHeaders(CHAT_URL, cred, wire),
-              Accept: "text/event-stream",
-              "Cache-Control": "no-cache",
-              "X-Model-Key": m.key,
-              "X-Model-Source": m.source,
-            }
-            let res
-            try {
-              res = await fetch(CHAT_URL, { method: "POST", headers, body: wire, signal: init.signal })
-            } catch (e) {
-              return errorResponse({ status: 502, message: e.message })
-            }
-            if (!res.ok) return errorResponse(failure(res.status, (await res.text()).slice(0, 1 << 20)))
-            return answer(res, chat)
+            return signed(await ask(chat, cred, init), renewed(cred))
           },
         }
       },
@@ -987,8 +1044,17 @@ export async function QoderAuthPlugin({ client }) {
       id: ID,
       async models(provider, { auth } = {}) {
         if (auth?.type !== "oauth") return provider.models
+        let cred
+        try {
+          cred = await fresh(async () => auth)
+        } catch (e) {
+          // the built-in listed through QoderCredentialOf: a refused job
+          // refresh marked the account there; anything else marked nothing
+          if (e?.expired) throw Object.assign(new Error(e.message), { signIn: "expired" })
+          return provider.models
+        }
+        if (renewals.has(cred)) unsaid.add(cred.uid)
         try {
-          const cred = await fresh(async () => auth)
           const ms = await models(cred, true)
           if (!ms.length) return provider.models
           return Object.fromEntries(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magpie-community/opencode-qoder-auth",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Qoder subscription in OpenCode and magpie",
   "type": "module",
   "main": "./index.mjs",