@goodandready/dsh-subscriptions 0.5.6 → 0.5.22

package/lib/importers/coding-agents.js

@@ -0,0 +1,37 @@
+import { readFile } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+export async function discoverCodingAgentConfigs() {
+  const configs = {}
+
+  // 1. Aider (.aider.conf.yml)
+  try {
+    const p = join(homedir(), '.aider.conf.yml')
+    const text = await readFile(p, 'utf8')
+    configs.aider = {
+      name: 'Aider Config',
+      path: p,
+      found: true,
+      raw: text
+    }
+  } catch {
+    // not present
+  }
+
+  // 2. Roo-Code / Roo-Cline settings
+  try {
+    const p = join(homedir(), '.roo-code', 'settings.json')
+    const text = await readFile(p, 'utf8')
+    configs.roocode = {
+      name: 'Roo-Code Config',
+      path: p,
+      found: true,
+      raw: text
+    }
+  } catch {
+    // not present
+  }
+
+  return configs
+}

package/lib/index.js

@@ -375,7 +375,7 @@ export function apply(ctx, config) {
       verifier: row.verifier,
       challenge: row.challenge,
       state: row.state,
-    }, code, fetchForRef(ref))
+    }, code, fetchForRef(ref) || fetch)
     const slots = normalizeSlots(live().slots)
     const slot = slots.find((s) => s.ref === ref)
     if (slot && slot.label) blob.label = slot.label
@@ -925,7 +925,7 @@ export function apply(ctx, config) {
       }
       try {
         const cfg = vendorConfig(provider, live())
-        const start = await vendor.deviceStart(cfg, fetchForRef(oauthRef(provider, index)))
+        const start = await vendor.deviceStart(cfg, (fetchForRef(oauthRef(provider, index)) || fetch))
         const state = 'dev-' + Date.now() + '-' + Math.random().toString(36).slice(2, 10)
         sweepPending(Date.now())
         pending.set(state, {
@@ -974,7 +974,7 @@ export function apply(ctx, config) {
       const vendor = getVendor(row.provider)
       try {
         const cfg = vendorConfig(row.provider, live())
-        const out = await vendor.devicePoll(cfg, { deviceAuthId: row.deviceAuthId, userCode: row.userCode }, fetchForRef(row.ref))
+        const out = await vendor.devicePoll(cfg, { deviceAuthId: row.deviceAuthId, userCode: row.userCode }, (fetchForRef(row.ref) || fetch))
         if (out.status !== 'authorized') {
           writeJson(res, 200, { ok: true, status: out.status })
           return
@@ -1154,17 +1154,45 @@ export function apply(ctx, config) {
         writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'same-origin only' } })
         return
       }
-      const body = await readBody(req).catch(() => null)
+      let body
+      try {
+        body = JSON.parse((await readBody(req, 16 * 1024)).toString('utf8') || '{}')
+      } catch {
+        body = null
+      }
       if (!body || !body.provider) {
         writeJson(res, 400, { ok: false, error: { code: 'bad_request', message: 'missing provider' } })
         return
       }
       try {
         const blob = await loadLocalCliBlob(body.provider)
-        const slot = normalizeSlots(live().slots).find((s) => s.provider === body.provider && s.index === (Number(body.index) || 1))
-        const ref = slot ? slot.ref : `${body.provider.toUpperCase()}_OAUTH_${Number(body.index) || 1}`
+        const prov = body.provider
+        const idx = Number(body.index) || 1
+        const curSlots = Array.isArray(live().slots) ? live().slots.slice() : []
+        const exists = curSlots.some((s) => s && s.provider === prov && Number(s.index) === idx)
+        if (!exists && settingsApi) {
+          const nextSlots = curSlots.concat([{
+            provider: prov,
+            index: idx,
+            label: blob.email || '',
+          }])
+          const parsed = Config({ ...live(), slots: stripLegacySlots(nextSlots) })
+          await settingsApi.replace(parsed)
+          syncCustomVendors()
+        }
+        const slot = normalizeSlots(live().slots).find((s) => s.provider === prov && s.index === idx)
+        const ref = slot ? slot.ref : `${prov.toUpperCase()}_OAUTH_${idx}`
         await store.saveBlob(ref, blob)
-        writeJson(res, 200, { ok: true, ref, provider: body.provider, email: blob.email || '' })
+        await syncAdapter()
+        refreshModels().catch(() => {})
+        writeJson(res, 200, {
+          ok: true,
+          ref,
+          provider: prov,
+          email: blob.email || '',
+          accounts: await accountsView(),
+          config: publicConfig(live()),
+        })
       } catch (e) {
         writeJson(res, 400, { ok: false, error: { message: String(e && e.message || e) } })
       }

package/lib/latency-heatmap.js

@@ -0,0 +1,26 @@
+export class LatencyHeatmap {
+  constructor() {
+    // 24-hour slots: map provider -> array of 24 hourly averages
+    this.matrix = new Map()
+  }
+
+  recordHourlyPing(provider, hourIndex, latencyMs) {
+    const p = provider || 'unknown'
+    if (!this.matrix.has(p)) {
+      this.matrix.set(p, new Array(24).fill(null))
+    }
+    const arr = this.matrix.get(p)
+    const idx = Math.max(0, Math.min(23, hourIndex))
+    arr[idx] = latencyMs
+  }
+
+  getHeatmap(provider) {
+    const arr = this.matrix.get(provider) || new Array(24).fill(null)
+    return arr.map((latency) => {
+      if (latency == null) return { latency: null, color: 'gray' }
+      if (latency < 400) return { latency, color: 'green' }
+      if (latency < 1200) return { latency, color: 'yellow' }
+      return { latency, color: 'red' }
+    })
+  }
+}

package/lib/latency-score.js

@@ -0,0 +1,36 @@
+export class LatencyTracker {
+  constructor(sampleLimit = 10) {
+    this.samples = new Map()
+    this.limit = sampleLimit
+  }
+
+  record(slotRef, latencyMs) {
+    if (!slotRef || typeof latencyMs !== 'number' || latencyMs < 0) return
+    if (!this.samples.has(slotRef)) {
+      this.samples.set(slotRef, [])
+    }
+    const arr = this.samples.get(slotRef)
+    arr.push(latencyMs)
+    if (arr.length > this.limit) arr.shift()
+  }
+
+  getAverage(slotRef) {
+    const arr = this.samples.get(slotRef)
+    if (!arr || !arr.length) return null
+    const sum = arr.reduce((acc, v) => acc + v, 0)
+    return Math.round(sum / arr.length)
+  }
+
+  getHealthScore(slotRef) {
+    const avg = this.getAverage(slotRef)
+    if (avg == null) return 100
+    if (avg < 300) return 100
+    if (avg < 800) return 85
+    if (avg < 2000) return 60
+    return 30
+  }
+
+  clear() {
+    this.samples.clear()
+  }
+}

package/lib/multi-tenant.js

@@ -0,0 +1,16 @@
+export function filterAccountsForUser(accounts, userContext) {
+  const list = Array.isArray(accounts) ? accounts : []
+  if (!userContext || userContext.isAdmin) {
+    return list // Admin sees all
+  }
+
+  const username = userContext.username || userContext.userId || userContext.sub
+  if (!username) return []
+
+  return list.filter((acc) => {
+    if (!acc.allowedUsers || !Array.isArray(acc.allowedUsers)) {
+      return true // Public in pool
+    }
+    return acc.allowedUsers.includes(username)
+  })
+}

package/lib/network-benchmark.js

@@ -0,0 +1,23 @@
+export async function benchmarkEndpoint(url, fetchImpl) {
+  const impl = fetchImpl || fetch
+  const start = Date.now()
+  try {
+    const res = await impl(url, { method: 'HEAD', signal: AbortSignal.timeout(4000) })
+    const ttfb = Date.now() - start
+    return {
+      url,
+      ok: res.ok,
+      status: res.status,
+      latencyMs: ttfb,
+      grade: ttfb < 300 ? 'A' : (ttfb < 800 ? 'B' : 'C')
+    }
+  } catch (err) {
+    return {
+      url,
+      ok: false,
+      error: err.message,
+      latencyMs: Date.now() - start,
+      grade: 'F'
+    }
+  }
+}

package/lib/pkce-store.js

@@ -0,0 +1,28 @@
+const pkceStates = new Map()
+const STATE_TTL_MS = 10 * 60 * 1000 // 10 minutes
+
+export function storePkceState(state, verifier) {
+  if (!state || !verifier) return
+  pkceStates.set(state, {
+    verifier,
+    createdAt: Date.now()
+  })
+}
+
+export function consumePkceState(state) {
+  if (!state) return null
+  const entry = pkceStates.get(state)
+  if (!entry) return null
+
+  // Single-use consumption (prevent INVALID_REPLAY_STATE)
+  pkceStates.delete(state)
+
+  if (Date.now() - entry.createdAt > STATE_TTL_MS) {
+    return null // expired
+  }
+  return entry.verifier
+}
+
+export function clearPkceStates() {
+  pkceStates.clear()
+}

package/lib/preflight-tokens.js

@@ -0,0 +1,23 @@
+export function estimateTokens(text) {
+  if (!text || typeof text !== 'string') return 0
+  // Average English: ~4 chars per token; CJK/Code: ~1.5 - 2 chars per token
+  const hasCjk = /[\u4e00-\u9fa5]/.test(text)
+  const ratio = hasCjk ? 2 : 3.8
+  return Math.max(1, Math.ceil(text.length / ratio))
+}
+
+export function validateContextLimit(messages, contextWindowLimit = 128000) {
+  let totalChars = 0
+  for (const m of messages || []) {
+    const content = typeof m.content === 'string' ? m.content : JSON.stringify(m.content || '')
+    totalChars += content.length
+  }
+  const estimated = estimateTokens(totalChars > 0 ? 'x'.repeat(totalChars) : '')
+  const safe = estimated <= contextWindowLimit * 0.95
+  return {
+    estimatedTokens: estimated,
+    limit: contextWindowLimit,
+    isSafe: safe,
+    marginTokens: Math.max(0, Math.floor(contextWindowLimit * 0.95 - estimated))
+  }
+}

package/lib/proactive-refresh.js

@@ -0,0 +1,37 @@
+export class ProactiveTokenRefreshDaemon {
+  constructor({ refreshLeadMs = 15 * 60 * 1000, checkIntervalMs = 60 * 1000 } = {}) {
+    this.refreshLeadMs = refreshLeadMs // refresh 15 min before token expires
+    this.checkIntervalMs = checkIntervalMs
+    this.timer = null
+  }
+
+  start(getAccountsFn, refreshFn) {
+    if (this.timer) return
+    this.timer = setInterval(async () => {
+      try {
+        const accounts = (typeof getAccountsFn === 'function' && await getAccountsFn()) || []
+        const now = Date.now()
+        for (const acc of accounts) {
+          if (!acc || !acc.expiresAt || !acc.refreshToken) continue
+          const expiresAt = Number(acc.expiresAt)
+          if (expiresAt - now <= this.refreshLeadMs && expiresAt > now) {
+            if (typeof refreshFn === 'function') {
+              await refreshFn(acc)
+            }
+          }
+        }
+      } catch {
+        // silent catch on daemon tick
+      }
+    }, this.checkIntervalMs)
+
+    if (this.timer.unref) this.timer.unref()
+  }
+
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer)
+      this.timer = null
+    }
+  }
+}

package/lib/prompt-cache-warmer.js

@@ -0,0 +1,44 @@
+const warmedSlots = new Map()
+
+export class PromptCacheWarmer {
+  constructor(ttlMs = 4.5 * 60 * 1000) {
+    this.ttlMs = ttlMs // default warm-up every 4.5 min before 5 min Anthropic cache expires
+    this.activeTimers = new Map()
+  }
+
+  touchSession(sessionId, slotRef, warmFn) {
+    if (!sessionId || !slotRef || typeof warmFn !== 'function') return
+    if (this.activeTimers.has(sessionId)) {
+      clearTimeout(this.activeTimers.get(sessionId))
+    }
+
+    const timer = setTimeout(async () => {
+      try {
+        await warmFn(slotRef, sessionId)
+        warmedSlots.set(sessionId, Date.now())
+      } catch {
+        // quiet error on background warm-up
+      }
+    }, this.ttlMs)
+
+    if (timer.unref) timer.unref()
+    this.activeTimers.set(sessionId, timer)
+  }
+
+  cancelSession(sessionId) {
+    if (this.activeTimers.has(sessionId)) {
+      clearTimeout(this.activeTimers.get(sessionId))
+      this.activeTimers.delete(sessionId)
+    }
+  }
+
+  isWarmed(sessionId) {
+    return warmedSlots.has(sessionId)
+  }
+
+  clear() {
+    for (const t of this.activeTimers.values()) clearTimeout(t)
+    this.activeTimers.clear()
+    warmedSlots.clear()
+  }
+}

package/lib/quarantine.js

@@ -0,0 +1,38 @@
+export const REASON_RATE_LIMIT = 'RATE_LIMIT'
+export const REASON_HARD_LIMIT = 'HARD_LIMIT'
+export const REASON_REVOKED = 'TOKEN_REVOKED'
+
+export function quarantineDuration(reason) {
+  switch (reason) {
+    case REASON_HARD_LIMIT:
+      return 24 * 60 * 60 * 1000 // 24 hours
+    case REASON_REVOKED:
+      return 7 * 24 * 60 * 60 * 1000 // 7 days (requires re-auth)
+    case REASON_RATE_LIMIT:
+    default:
+      return 60 * 60 * 1000 // 1 hour
+  }
+}
+
+export function putInQuarantine(account, reason, nowMs = Date.now()) {
+  const duration = quarantineDuration(reason)
+  return {
+    ...account,
+    quarantineReason: reason,
+    quarantineUntil: nowMs + duration,
+    status: 'quarantine'
+  }
+}
+
+export function isQuarantined(account, nowMs = Date.now()) {
+  if (!account || !account.quarantineUntil) return false
+  return Number(account.quarantineUntil) > Number(nowMs)
+}
+
+export function releaseFromQuarantine(account) {
+  const next = { ...account }
+  delete next.quarantineReason
+  delete next.quarantineUntil
+  if (next.status === 'quarantine') next.status = 'active'
+  return next
+}

package/lib/ratelimit-parser.js

@@ -0,0 +1,24 @@
+export function parseRateLimitHeaders(headers) {
+  if (!headers || typeof headers !== 'object') return null
+
+  const get = (key) => {
+    const k = Object.keys(headers).find((h) => h.toLowerCase() === key.toLowerCase())
+    return k ? headers[k] : null
+  }
+
+  const remainingTokens = get('x-ratelimit-remaining-tokens')
+  const resetTokens = get('x-ratelimit-reset-tokens')
+  const remainingRequests = get('x-ratelimit-remaining-requests')
+  const resetRequests = get('x-ratelimit-reset-requests')
+
+  if (!remainingTokens && !resetTokens && !remainingRequests && !resetRequests) {
+    return null
+  }
+
+  return {
+    remainingTokens: remainingTokens != null ? Number(remainingTokens) : null,
+    resetTokensTime: resetTokens || null,
+    remainingRequests: remainingRequests != null ? Number(remainingRequests) : null,
+    resetRequestsTime: resetRequests || null
+  }
+}

package/lib/reconnect-stream.js

@@ -0,0 +1,21 @@
+export async function* streamWithReconnect(streamProducer, { maxReconnects = 2 } = {}) {
+  let reconnects = 0
+  let emittedCount = 0
+
+  while (true) {
+    try {
+      for await (const chunk of streamProducer(emittedCount)) {
+        emittedCount++
+        yield chunk
+      }
+      return
+    } catch (err) {
+      reconnects++
+      if (reconnects > maxReconnects) {
+        throw err
+      }
+      // Brief pause before reconnect
+      await new Promise((r) => setTimeout(r, 250))
+    }
+  }
+}

package/lib/reset-toast.js

@@ -0,0 +1,38 @@
+export class ResetNotificationManager {
+  constructor() {
+    this.scheduledAlerts = new Map()
+  }
+
+  scheduleResetNotice(accountRef, resetAt, onResetAlert) {
+    if (!accountRef || !resetAt || resetAt <= Date.now()) return
+    if (this.scheduledAlerts.has(accountRef)) {
+      clearTimeout(this.scheduledAlerts.get(accountRef))
+    }
+
+    const delay = Math.max(0, resetAt - Date.now())
+    const timer = setTimeout(() => {
+      this.scheduledAlerts.delete(accountRef)
+      if (typeof onResetAlert === 'function') {
+        onResetAlert({
+          accountRef,
+          message: `Subscription quota reset! Slot ${accountRef} is ready to use.`
+        })
+      }
+    }, delay)
+
+    if (timer.unref) timer.unref()
+    this.scheduledAlerts.set(accountRef, timer)
+  }
+
+  cancel(accountRef) {
+    if (this.scheduledAlerts.has(accountRef)) {
+      clearTimeout(this.scheduledAlerts.get(accountRef))
+      this.scheduledAlerts.delete(accountRef)
+    }
+  }
+
+  clear() {
+    for (const t of this.scheduledAlerts.values()) clearTimeout(t)
+    this.scheduledAlerts.clear()
+  }
+}

package/lib/revocation.js

@@ -0,0 +1,25 @@
+const REVOKED_ERRORS = new Set([
+  'invalid_grant',
+  'token_revoked',
+  'account_deactivated',
+  'session_expired'
+])
+
+export function isTokenRevokedError(err) {
+  if (!err) return false
+  const msg = String(err.message || err.error || err.code || '').toLowerCase()
+  for (const pattern of REVOKED_ERRORS) {
+    if (msg.includes(pattern)) return true
+  }
+  return false
+}
+
+export function handleAccountRevocation(account) {
+  return {
+    ...account,
+    hasToken: false,
+    status: 'revoked',
+    needsReauth: true,
+    revokedAt: Date.now()
+  }
+}

package/lib/rotate.js

@@ -1,19 +1,20 @@
+import { isQuarantined } from './quarantine.js'
+import { getPinnedAccountRef, pinSession } from './session-pin.js'
+
 const SWITCH_CODES = new Set([
-  "RATE_LIMIT",
-  "QUOTA",
-  "QUOTA_EXCEEDED",
+  'RATE_LIMIT',
+  'QUOTA',
+  'QUOTA_EXCEEDED',
 ])
 
 export function isSwitchableError(err) {
-  if (!err || typeof err !== "object") return false
+  if (!err || typeof err !== 'object') return false
   const code = err.code || (err.failure && err.failure.code)
   if (SWITCH_CODES.has(code)) return true
   const status = err.status || err.statusCode
-  return status === 429
+  return status === 429 || status === 500 || status === 502 || status === 503
 }
 
-// #87: family classification. Cooldowns are scoped to the model family that
-// hit the limit, so a reasoning 429 does not block standard models.
 export function modelFamily(provider, model) {
   const id = String(model || '')
   if (provider === 'claude') return /thinking/i.test(id) ? 'reasoning' : 'standard'
@@ -22,8 +23,6 @@ export function modelFamily(provider, model) {
   return 'standard'
 }
 
-// Legacy cooldowns (no family list) block everything; scoped ones block only
-// their own family. An unknown family never blocks a differently-scoped cooldown.
 export function cooldownBlocks(acc, family) {
   const fams = acc && acc.cooldownFamilies
   if (!Array.isArray(fams) || !fams.length) return true
@@ -36,17 +35,17 @@ export function pickAccount(accounts, nowMs, opts) {
   const now = Number(nowMs) || 0
   const thrRaw = opts && opts.switchAtRemaining != null ? Number(opts.switchAtRemaining) : 0
   const thr = Number.isFinite(thrRaw) ? thrRaw : 0
+  const isVipRequest = Boolean(opts && opts.vip)
+  const targetTag = opts && opts.tag
+  const targetSession = opts && opts.sessionId
+
   function isQuotaExhausted(acc) {
     if (!thr || thr <= 0) return false
     const q = acc.quota
     if (!q) return false
     if (q.resetAt && Number(q.resetAt) <= now) return false
     if (q.remaining == null) return false
-    // Если до сброса меньше минуты — переключаемся, не тратя остаток,
-    // независимо от порога (аккаунт всё равно скоро обнулится).
     if (q.resetAt && Number(q.resetAt) - now < 60000) return true
-    // Если остаток меньше порога — считаем исчерпанным, чтобы не тратить
-    // последние проценты перед отказом.
     let below = false
     if (q.limit != null && q.limit > 0 && thr > 0 && thr < 1) {
       const frac = q.remaining / q.limit
@@ -56,33 +55,87 @@ export function pickAccount(accounts, nowMs, opts) {
     }
     return below
   }
+
   function isUsageExhausted(acc) {
     if (acc.usagePercent == null || Number(acc.usagePercent) < 100) return false
     const q = acc.quota
     if (q && q.resetAt && Number(q.resetAt) <= now) return false
     return true
   }
+
+  // Sticky Session Pinning (#170)
+  if (targetSession) {
+    const pinnedRef = getPinnedAccountRef(targetSession)
+    if (pinnedRef) {
+      const pinned = list.find((a) => (a.ref || a.id) === pinnedRef)
+      if (pinned && pinned.hasToken && !isQuarantined(pinned, now)) {
+        const isCooldown = pinned.cooldownUntil && Number(pinned.cooldownUntil) > now && cooldownBlocks(pinned, opts && opts.family)
+        if (!isCooldown && !isQuotaExhausted(pinned) && !isUsageExhausted(pinned)) {
+          return pinned
+        }
+      }
+    }
+  }
+
+  // 3-Tier priority:
+  // Tier 0: Has known quota & healthy
+  // Tier 1: Quota unknown (null) & healthy
+  // Tier 2: Cooldown, quarantine or exhausted
   const tiers = [[], [], []]
   const fallback = []
+
   for (const acc of list) {
     if (!acc || !acc.hasToken) continue
+
+    // VIP Slot Reservation (#175)
+    if (acc.vipOnly && !isVipRequest) continue
+
+    // Tag-based filtering (#173)
+    if (targetTag && Array.isArray(acc.tags) && !acc.tags.includes(targetTag)) continue
+
     const isCooldown = acc.cooldownUntil && Number(acc.cooldownUntil) > now && cooldownBlocks(acc, opts && opts.family)
+    const inQuarantine = isQuarantined(acc, now)
     const exhausted = isQuotaExhausted(acc) || isUsageExhausted(acc)
-    if (isCooldown || exhausted) {
+
+    if (isCooldown || inQuarantine || exhausted) {
       tiers[2].push(acc)
       fallback.push(acc)
       continue
     }
+
     if (!acc.quota) tiers[1].push(acc)
     else tiers[0].push(acc)
   }
-  // Внутри здоровых тиров предпочитаем аккаунт с более высоким health-счётом
+
   for (const tier of tiers) {
     if (tier.length) {
-      tier.sort((a, b) => (b.healthScore || 100) - (a.healthScore || 100))
-      return tier[0]
+      tier.sort((a, b) => {
+        // 1. Least Remaining Window (#167)
+        if (a.quota && b.quota && a.quota.resetAt && b.quota.resetAt) {
+          const aReset = Number(a.quota.resetAt)
+          const bReset = Number(b.quota.resetAt)
+          if (Math.abs(aReset - bReset) > 300000) {
+            return aReset - bReset
+          }
+        }
+
+        // 2. Weighted Round Robin: Pro/Team weight (#171)
+        const aWeight = a.weight || (a.isPro ? 5 : 1)
+        const bWeight = b.weight || (b.isPro ? 5 : 1)
+        if (aWeight !== bWeight) return bWeight - aWeight
+
+        // 3. Health Score
+        return (b.healthScore || 100) - (a.healthScore || 100)
+      })
+
+      const chosen = tier[0]
+      if (targetSession && chosen) {
+        pinSession(targetSession, chosen.ref || chosen.id)
+      }
+      return chosen
     }
   }
+
   if (fallback.length) return fallback[0]
   return null
 }

package/lib/savings-calculator.js

@@ -0,0 +1,14 @@
+export function calculateCacheSavings({ cachedTokens = 0, totalInputTokens = 0, ratePerMillion = 3.0 } = {}) {
+  const hitRate = totalInputTokens > 0 ? Math.round((cachedTokens / totalInputTokens) * 100) : 0
+  // Anthropic / OpenAI prompt cache discount is typically 90% (cached tokens cost 10% of standard input)
+  const fullCost = (cachedTokens / 1_000_000) * ratePerMillion
+  const discountedCost = fullCost * 0.1
+  const savedDollars = Math.round((fullCost - discountedCost) * 100) / 100
+
+  return {
+    cachedTokens,
+    totalInputTokens,
+    hitRatePercent: hitRate,
+    estimatedSavedDollars: savedDollars
+  }
+}