@magpie-community/opencode-cursor-auth 0.2.12 → 0.2.13

package/index.mjs

@@ -1358,17 +1358,18 @@ function usageOf(uf) {
 // event: its step looks for it as before, and is guessed without it.
 const STEP_WAIT = { first: 1500, every: 500, until: 6000, ask: 5000, skipAfter: 3, retryEvery: 10, owedAt: 5000, owedFor: 600_000 }
 
-// claimed are the usage events already counted, by conversation and time,
-// so that two steps of one conversation never count the same one.
+// claimed are the usage events already counted, by account, conversation
+// and time, so that two steps of one conversation never count the same one.
 const claimed = new Map()
 
-// owed are what each conversation still owes, by conversation_id: n Runs
-// whose events are to be counted, the earliest started at since, looked
-// for from ready on; and carry, a count collected that no step gave out.
+// owed are what each account's conversation still owes, by credential
+// fingerprint and conversation_id: n Runs whose events are to be counted,
+// the earliest started at since, looked for from ready on; and carry, a
+// count collected that no step gave out.
 const owed = new Map()
 
-// flights are each conversation's collections still going, which a step
-// that ends the turn waits for.
+// flights are each account's conversation collections still going, which
+// a step that ends the turn waits for.
 const flights = new Map()
 
 // unreadable are the accounts (by token) whose usage events Cursor won't
@@ -1378,6 +1379,7 @@ const flights = new Map()
 const unreadable = new Map()
 const misses = new Map()
 const tokKey = (tok) => createHash("sha256").update(tok).digest("hex")
+const usageKey = (tok, conv) => tokKey(tok) + "\0" + conv
 function canRead(tok) {
   const at = unreadable.get(tokKey(tok))
   if (at === undefined) return true
@@ -1394,12 +1396,12 @@ function addUsage(a, b) {
   return a
 }
 
-// owe adds to conversation conv's debt.
-function owe(conv, { since = Date.now(), n = 0, ready = Date.now(), carry = null }) {
+// owe adds to the account/conversation's debt.
+function owe(key, { since = Date.now(), n = 0, ready = Date.now(), carry = null }) {
   for (const [k, d] of owed) if (Date.now() - d.since > STEP_WAIT.owedFor) owed.delete(k)
   if (n <= 0 && !carry) return
-  const d = owed.get(conv)
-  if (!d) return void owed.set(conv, { since, n, ready, carry: carry && { ...carry } })
+  const d = owed.get(key)
+  if (!d) return void owed.set(key, { since, n, ready, carry: carry && { ...carry } })
   d.since = Math.min(d.since, since)
   d.n += n
   d.ready = Math.min(d.ready, ready)
@@ -1413,6 +1415,7 @@ function owe(conv, { since = Date.now(), n = 0, ready = Date.now(), carry = null
 // Polling, they are looked for as STEP_WAIT says, from `first` on, until
 // all show; else asked for once.
 async function usageEvents(tok, conv, since, want, { poll = false, first = STEP_WAIT.first, signal } = {}) {
+  const key = usageKey(tok, conv)
   const end = Date.now() + STEP_WAIT.until
   const wait = (ms) => new Promise((r) => {
     const t = setTimeout(r, ms)
@@ -1439,11 +1442,11 @@ async function usageEvents(tok, conv, since, want, { poll = false, first = STEP_
       }
       const evs = res.ok ? ((await res.json())?.usageEventsDisplay ?? []) : []
       const found = evs
-        .filter((e) => e?.conversationId === conv && e.tokenUsage && num(e.timestamp) >= since - 1000 && !claimed.has(conv + "\0" + e.timestamp))
+        .filter((e) => e?.conversationId === conv && e.tokenUsage && num(e.timestamp) >= since - 1000 && !claimed.has(key + "\0" + e.timestamp))
         .sort((a, b) => num(a.timestamp) - num(b.timestamp))
         .slice(0, want - got)
       for (const ev of found) {
-        claimed.set(conv + "\0" + ev.timestamp, Date.now())
+        claimed.set(key + "\0" + ev.timestamp, Date.now())
         const t = ev.tokenUsage
         const u = { input: num(t.inputTokens), output: num(t.outputTokens), cacheRead: num(t.cacheReadTokens), cacheWrite: num(t.cacheWriteTokens), reasoning: 0 }
         usage = addUsage(usage ?? ZERO(), u)
@@ -1464,31 +1467,32 @@ async function stepUsage(tok, conv, since, signal) {
   return (await usageEvents(tok, conv, since, 1, { poll: true, signal })).usage
 }
 
-// collect takes conversation conv's debt and asks for its events (polling
-// when poll): what was carried and what was found (usage), what was
-// carried alone (carry) and the events found (events), and whether any is
+// collect takes the account's debt for conversation conv and asks for its
+// events (polling when poll): what was carried and what was found (usage),
+// what was carried alone (carry) and the events found (events), and whether any is
 // still owed (short), which is owed on. What comes back once the Run that
 // asked is over (over() true) is carried to the next instead.
 function collect(tok, conv, { poll = false, first, signal, over = () => false } = {}) {
-  const d = owed.get(conv)
+  const key = usageKey(tok, conv)
+  const d = owed.get(key)
   if (!d) return Promise.resolve({ usage: null, carry: null, events: [], short: false })
-  owed.delete(conv)
+  owed.delete(key)
   const p = (async () => {
     let r = { usage: null, events: [], got: 0 }
     if (d.n > 0 && canRead(tok)) r = await usageEvents(tok, conv, d.since, d.n, { poll, first, signal }).catch(() => r)
     const short = d.n > r.got && canRead(tok)
-    if (short) owe(conv, { since: d.since, n: d.n - r.got, ready: d.ready })
+    if (short) owe(key, { since: d.since, n: d.n - r.got, ready: d.ready })
     const carry = d.carry && { ...d.carry }
     const usage = addUsage(d.carry, r.usage)
     if (!over()) return { usage, carry, events: r.events ?? [], short }
-    owe(conv, { carry: usage })
+    owe(key, { carry: usage })
     return { usage: null, carry: null, events: [], short }
   })()
-  const set = flights.get(conv) ?? new Set()
-  flights.set(conv, set.add(p))
+  const set = flights.get(key) ?? new Set()
+  flights.set(key, set.add(p))
   p.finally(() => {
     set.delete(p)
-    if (!set.size && flights.get(conv) === set) flights.delete(conv)
+    if (!set.size && flights.get(key) === set) flights.delete(key)
   })
   return p
 }
@@ -1515,6 +1519,7 @@ function collect(tok, conv, { poll = false, first, signal, over = () => false }
 // count would be told in the wrong field, never twice nor lost.
 function ledger(tok, conv, since, signal, kept) {
   const key = tokKey(tok)
+  const debtKey = usageKey(tok, conv)
   let mine = null // this Run's own, collected, not given out yet
   let theirs = null // earlier Runs', collected, not given out yet
   let over = false
@@ -1528,7 +1533,7 @@ function ledger(tok, conv, since, signal, kept) {
       return r
     })
   let collecting = null
-  const debt = kept ? owed.get(conv) : undefined
+  const debt = kept ? owed.get(debtKey) : undefined
   const timer = debt ? setTimeout(() => (collecting = gather()), Math.max(0, debt.ready - Date.now())) : null
   timer?.unref?.()
   const takeMine = () => {
@@ -1552,7 +1557,7 @@ function ledger(tok, conv, since, signal, kept) {
         else if (!r.refused) misses.set(key, m + 1)
         return r.usage ?? null
       }
-      owe(conv, { since, n: 1, ready: Date.now() + STEP_WAIT.owedAt })
+      owe(debtKey, { since, n: 1, ready: Date.now() + STEP_WAIT.owedAt })
       if (waits) {
         const r = await gather({ poll: true, signal })
         if (!canRead(tok)) return null
@@ -1565,8 +1570,8 @@ function ledger(tok, conv, since, signal, kept) {
       if (!kept) return null
       if (final) {
         await collecting
-        await Promise.all([...(flights.get(conv) ?? [])])
-        if (owed.has(conv)) await gather({ poll: owed.get(conv).n > 0, first: 0, signal })
+        await Promise.all([...(flights.get(debtKey) ?? [])])
+        if (owed.has(debtKey)) await gather({ poll: owed.get(debtKey).n > 0, first: 0, signal })
       }
       return take()
     },
@@ -1574,7 +1579,7 @@ function ledger(tok, conv, since, signal, kept) {
       over = true
       clearTimeout(timer)
       const u = take()
-      if (u) owe(conv, { carry: u })
+      if (u) owe(debtKey, { carry: u })
     },
   }
 }
@@ -1666,12 +1671,21 @@ async function agentURL(tok, fresh) {
 // connection that failed (refused, no network) or a stream the server
 // refused leaves the next Run to try HTTP/2 again.
 let h1Until = 0
+const cancelledOpen = () => ({ error: { status: 410, message: "the request was cancelled" }, h2Failed: false })
 async function open(base, headers, signal) {
+  if (signal?.aborted) return cancelledOpen()
   if (Date.now() >= h1Until) {
     const o = await openH2(base, headers, signal)
+    // The head can arrive just before abort, before this continuation owns it.
+    if (signal?.aborted) {
+      o.req?.close(http2.constants.NGHTTP2_CANCEL)
+      o.session?.destroy()
+      return cancelledOpen()
+    }
     if (!o.h2Failed) return o
     if (o.blocked) h1Until = Date.now() + H2.retryAfter
   }
+  if (signal?.aborted) return cancelledOpen()
   return openH1(headers, signal)
 }
 
@@ -1702,6 +1716,7 @@ function h2Blocked(e) {
 // than by being cancelled, says h2Failed, and blocked when h2Blocked says
 // so of the failure.
 function openH2(base, headers, signal) {
+  if (signal?.aborted) return Promise.resolve(cancelledOpen())
   return new Promise((resolve) => {
     const u = new URL(base)
     const session = http2.connect(u.origin)
@@ -1710,9 +1725,11 @@ function openH2(base, headers, signal) {
       if (done) return
       done = true
       clearTimeout(timer)
+      signal?.removeEventListener("abort", abort)
       session.destroy()
-      resolve({ error: { status: 502, message: e?.message ?? String(e) }, h2Failed, blocked: h2Failed && h2Blocked(e) })
+      resolve({ error: { status: h2Failed ? 502 : 410, message: e?.message ?? String(e) }, h2Failed, blocked: h2Failed && h2Blocked(e) })
     }
+    const abort = () => fail(new Error("the request was cancelled"), false)
     const timer = setTimeout(() => fail(Object.assign(new Error(`no answer over HTTP/2 in ${H2.wait / 1000}s`), { h2Timeout: true })), H2.wait)
     session.on("error", fail)
     const req = session.request({
@@ -1728,9 +1745,11 @@ function openH2(base, headers, signal) {
       if (done) return
       done = true
       clearTimeout(timer)
+      signal?.removeEventListener("abort", abort)
       resolve({ session, req, status: Number(h[":status"]) })
     })
-    signal?.addEventListener("abort", () => fail(new Error("the request was cancelled"), false), { once: true })
+    signal?.addEventListener("abort", abort, { once: true })
+    if (signal?.aborted) abort()
   })
 }
 
@@ -1750,23 +1769,29 @@ function connectCode(status) {
 // ends the stream with Connect's end frame, which runOnce reads as the
 // Run's own.
 function openH1(headers, signal) {
+  if (signal?.aborted) return Promise.resolve(cancelledOpen())
   const ac = new AbortController()
-  signal?.addEventListener("abort", () => ac.abort(), { once: true })
   const id = headers["x-request-id"]
   const h = { ...headers, "accept-encoding": "identity", "x-cursor-streaming": "true" }
   let ended = false
   let seq = 0
-  let chain = Promise.resolve()
+  let reader
   const req = new Duplex({
     read() {},
     write(chunk, _enc, cb) {
       // runOnce writes one whole frame each time
       const msg = Buffer.from(chunk).subarray(5)
       const n = seq++
-      chain = chain.then(() => (ended ? undefined : append(msg, n)))
-      cb()
+      // Keep the write buffered until its append finishes, so callbacks and
+      // drain reflect the pending upload rather than an unbounded promise chain.
+      append(msg, n).then(() => cb(), (e) => cb(e))
     },
   })
+  const cleanup = () => {
+    signal?.removeEventListener("abort", close)
+    ac.abort()
+    reader?.cancel().catch(() => {})
+  }
   const end = (body) => {
     if (ended || req.destroyed) return
     ended = true
@@ -1774,7 +1799,7 @@ function openH1(headers, signal) {
     f[0] = 2
     req.push(f)
     req.push(null)
-    ac.abort()
+    cleanup()
   }
   const failed = async (res) => {
     const text = await res.text().catch(() => "")
@@ -1788,6 +1813,7 @@ function openH1(headers, signal) {
   // (more time for a large one) ends the Run, as cursor-agent's
   // bidi_append_deadline_exceeded does: the messages after it wait on it.
   const append = async (msg, n) => {
+    if (ended || ac.signal.aborted) return
     const body = pb().str(1, msg.toString("hex")).bytes(2, pb().str(1, id).done()).varint(3, n).done()
     const ms = H1.appendWait + Math.ceil(body.length / 65536) * 1000
     const deadline = AbortSignal.timeout(ms)
@@ -1798,6 +1824,7 @@ function openH1(headers, signal) {
         body,
         signal: AbortSignal.any([ac.signal, deadline]),
       })
+      if (ended || ac.signal.aborted) { await res.body?.cancel().catch(() => {}); return }
       if (!res.ok) return failed(res)
       await res.arrayBuffer()
     } catch (e) {
@@ -1806,6 +1833,16 @@ function openH1(headers, signal) {
       end(JSON.stringify({ error: { code: "unavailable", message: `BidiAppend: ${e?.message ?? e}` } }))
     }
   }
+  const close = () => {
+    ended = true
+    cleanup()
+    req.destroy()
+  }
+  signal?.addEventListener("abort", close, { once: true })
+  if (signal?.aborted) {
+    close()
+    return Promise.resolve(cancelledOpen())
+  }
   ;(async () => {
     try {
       const res = await fetch(API + "/agent.v1.AgentService/RunSSE", {
@@ -1814,25 +1851,29 @@ function openH1(headers, signal) {
         body: frame(pb().str(1, id).done()),
         signal: ac.signal,
       })
+      if (ended || ac.signal.aborted) { await res.body?.cancel().catch(() => {}); return }
       if (!res.ok) return failed(res)
-      for await (const c of res.body) {
-        if (ended || req.destroyed) return
-        req.push(Buffer.from(c))
+      reader = res.body.getReader()
+      try {
+        while (!ended && !req.destroyed) {
+          const { value, done } = await reader.read()
+          if (done) break
+          if (!ended && !req.destroyed) req.push(Buffer.from(value))
+        }
+      } finally {
+        reader.releaseLock()
+        reader = undefined
       }
       if (!ended && !req.destroyed) {
         ended = true
         req.push(null)
+        cleanup()
       }
     } catch (e) {
       if (!ac.signal.aborted) end(JSON.stringify({ error: { code: "unavailable", message: `RunSSE: ${e?.message ?? e}` } }))
     }
   })()
-  const close = () => {
-    ended = true
-    ac.abort()
-    req.destroy()
-  }
-  return Promise.resolve({ session: { close, destroy: close }, req: Object.assign(req, { close }), status: 200, h1: true })
+  return Promise.resolve(signal?.aborted ? cancelledOpen() : { session: { close, destroy: close }, req: Object.assign(req, { close }), status: 200, h1: true })
 }
 
 // runOnce is one Run of the chat on the agent API at base: an async
@@ -1865,14 +1906,15 @@ async function runOnce({ tok, base, id, tools, conv, convID, signal, maxMode, pa
   if (o.error) return book.done(), o
   const { session, req } = o
   let closed = false
+  let heartbeat
   const send = (msg) => {
     if (!closed && !req.destroyed && req.writable) req.write(frame(msg))
   }
-  const heartbeat = setInterval(() => send(pb().bytes(7, EMPTY).done()), 5000) // the client is still there, as the CLI says
   const close = () => {
     if (closed) return
     closed = true
     clearInterval(heartbeat)
+    signal?.removeEventListener("abort", close)
     try {
       req.close(http2.constants.NGHTTP2_CANCEL)
     } catch {}
@@ -1880,6 +1922,13 @@ async function runOnce({ tok, base, id, tools, conv, convID, signal, maxMode, pa
     setTimeout(() => session.destroy(), 1000).unref?.()
   }
   signal?.addEventListener("abort", close, { once: true })
+  // Abort can win after open's head check but before this Run takes ownership.
+  if (signal?.aborted) {
+    close()
+    book.done()
+    return cancelledOpen()
+  }
+  heartbeat = setInterval(() => send(pb().bytes(7, EMPTY).done()), 5000) // the client is still there, as the CLI says
   send(first)
   if (o.status < 200 || o.status > 299) {
     const chunks = []
@@ -2397,4 +2446,4 @@ export async function CursorAuthPlugin() {
 }
 
 // for tests
-export const _internal = { onDemandOf,resetH1: () => (h1Until = 0), onH1: () => Date.now() < h1Until, H2, H1, h2Blocked, open, openH1, STEP_WAIT, stepUsage, ledger, owed, flights, misses, unreadable, catalog, usable, request, modelsOf, tokensOf, maxRequired, conversationID, usageOf, sessionOf, SESSION, errorResponse, kept, poolBase, conversation, buildRun, decode, exec, fields, pb, pbValue, pbAny, frame, frames, failure, toolsOf, expiry }
+export const _internal = { onDemandOf,resetH1: () => (h1Until = 0), onH1: () => Date.now() < h1Until, H2, H1, h2Blocked, open, openH1, openH2, STEP_WAIT, stepUsage, usageKey, ledger, owed, flights, misses, unreadable, catalog, usable, request, modelsOf, tokensOf, maxRequired, conversationID, usageOf, sessionOf, SESSION, errorResponse, kept, poolBase, conversation, buildRun, decode, exec, fields, pb, pbValue, pbAny, frame, frames, failure, toolsOf, expiry }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magpie-community/opencode-cursor-auth",
-  "version": "0.2.12",
+  "version": "0.2.13",
   "description": "Cursor subscriptions (Pro, Pro+, Ultra, Teams) in OpenCode and magpie, through the API cursor-agent talks to",
   "type": "module",
   "main": "./index.mjs",