@goodandready/dsh-subscriptions 0.6.22 → 0.6.23

package/lib/accounts-view.js

@@ -0,0 +1,84 @@
+import { normalizeSlots } from './accounts.js'
+import {
+  inspectGoogleAccount,
+  antigravityMetadata,
+  antigravityIdentityHeaders,
+} from './code-assist.js'
+
+export async function enrichAntigravityAccount(slot, info, store, fetch) {
+  if (!info.configured || slot.provider !== 'antigravity') return info
+  let blob
+  try { blob = await store.loadBlob(slot.ref) } catch { return info }
+  if (blob.validationUrl) {
+    return {
+      ...info,
+      validationUrl: blob.validationUrl,
+      validationMessage: blob.validationMessage || info.validationMessage || '',
+      paidTierName: blob.paidTierName || info.paidTierName || '',
+    }
+  }
+  try {
+    const fresh = await store.ensureFresh(slot.provider, blob, slot.ref)
+    const probe = await inspectGoogleAccount(fetch, fresh.accessToken, {
+      metadata: antigravityMetadata(fresh.projectId || ''),
+      extraHeaders: antigravityIdentityHeaders(fresh.projectId || ''),
+      projectId: fresh.projectId,
+    })
+    const next = { ...fresh }
+    if (probe.projectId && probe.projectId !== fresh.projectId) next.projectId = probe.projectId
+    if (probe.paidTierId) next.paidTierId = probe.paidTierId
+    if (probe.paidTierName) next.paidTierName = probe.paidTierName
+    if (probe.validation?.validationUrl) {
+      next.validationUrl = probe.validation.validationUrl
+      next.validationMessage = probe.validation.message || ''
+      await store.saveBlob(slot.ref, next)
+      return {
+        ...info,
+        validationUrl: next.validationUrl,
+        validationMessage: next.validationMessage,
+        paidTierName: next.paidTierName || '',
+      }
+    }
+    if (probe.notice?.message) {
+      next.accountNotice = probe.notice.message
+      await store.saveBlob(slot.ref, next)
+      return { ...info, accountNotice: next.accountNotice, paidTierName: next.paidTierName || '' }
+    }
+    if (probe.projectId || probe.paidTierId) await store.saveBlob(slot.ref, next)
+    return { ...info, paidTierName: next.paidTierName || info.paidTierName || '' }
+  } catch { /* keep settings responsive */ }
+  return info
+}
+
+export async function createAccountsView({ live, store, fetch, pmL }) {
+  const out = []
+  for (const slot of normalizeSlots(live().slots)) {
+    const info = await enrichAntigravityAccount(slot, await store.describeRef(slot.ref), store, fetch)
+    out.push({
+      provider: slot.provider,
+      index: slot.index,
+      ref: slot.ref,
+      label: pmL(slot.label || info.label),
+      configured: info.configured,
+      writable: info.writable,
+      cooldownUntil: info.cooldownUntil,
+      // Issue 303: expose the cooldown scope and quarantine so the card can
+      // explain why only some models are blocked.
+      cooldownFamilies: info.cooldownFamilies || null,
+      quarantineUntil: info.quarantineUntil || 0,
+      quarantineReason: info.quarantineReason || null,
+      healthScore: info.healthScore,
+      healthBadge: info.healthBadge,
+      usagePercent: info.usagePercent,
+      quota: info.quota || null,
+      usage: info.usage || null,
+      requests: store.getRequestCount(slot.ref) || null,
+      refreshError: info.refreshError || '',
+      validationUrl: info.validationUrl || '',
+      validationMessage: info.validationMessage || '',
+      accountNotice: info.accountNotice || '',
+      paidTierName: info.paidTierName || '',
+    })
+  }
+  return out
+}

package/lib/accounts.js

@@ -2,7 +2,7 @@ import { fetchWithTimeout } from "./http.js"
 import { credentialRef } from '@deepseek-ai/dsh-credentials'
 import { oauthRef, isProvider } from './refs.js'
 import { parseBlob, serializeBlob } from './blob.js'
-import { recordSwitch, recordExhaust, recordBroken, computeHealthScore } from './health.js'
+import { recordSwitch, recordExhaust, recordBroken, computeHealthScore, healthBadge } from './health.js'
 import { executeWithRetry } from './backoff.js'
 import { getVendor } from './vendors/index.js'
 
@@ -153,6 +153,8 @@ export function createAccountStore({ credentials, getConfig, fetchImpl, fetchFor
       quota: quotas.get(ref) || null,
       usage: windows.get(ref) || base.usage || null,
       health: health.get(ref) || null,
+      healthScore: computeHealthScore(health.get(ref) || null),
+      healthBadge: healthBadge(computeHealthScore(health.get(ref) || null)),
       usagePercent: usage.has(ref) ? usage.get(ref) : null,
       refreshError: refreshFailures.get(ref)?.error || '',
       validationUrl: base.validationUrl || '',
@@ -179,6 +181,7 @@ export function createAccountStore({ credentials, getConfig, fetchImpl, fetchFor
         cooldownFamilies: info.cooldownFamilies || null,
         quota: info.quota || null,
         healthScore: computeHealthScore(info.health),
+        healthBadge: healthBadge(computeHealthScore(info.health)),
         quarantineUntil: inQ ? q.until : 0,
         quarantineReason: inQ ? q.reason : null,
         label: slot.label || info.label,
@@ -271,7 +274,7 @@ export function createAccountStore({ credentials, getConfig, fetchImpl, fetchFor
             for (const th of THRESHOLDS) {
               if (pct >= th && prev < th) {
                 notifyThresholds.set(key, th)
-                try { onLimitNotice && onLimitNotice(slot.provider, slot.ref, win, th) } catch (err) { /* ignore notification failure */ }
+                try { onLimitNotice && onLimitNotice(slot.provider, slot.ref, win, th) } catch { /* ignore notification failure */ }
                 break
               }
             }

package/lib/adapter-manager.js

@@ -0,0 +1,300 @@
+import { SubscriptionAdapter } from './adapter.js'
+import { resolveFallbackVendor, mapFallbackModel } from './cascade.js'
+import { normalizeSlots, vendorConfig } from './accounts.js'
+import { PROVIDERS, isProvider, oauthRef } from './refs.js'
+import { credentialRef } from '@deepseek-ai/dsh-credentials'
+import { getVendor } from './vendors/index.js'
+import { Config } from './config-schema.js'
+
+export function createAdapterManager({
+  ctx,
+  live,
+  store,
+  logger,
+  fetch,
+  fetchForRef,
+  recordHistory,
+  getSettingsApi,
+  syncCustomVendors,
+  syncOllama,
+  stripLegacySlots,
+}) {
+  let handle
+  let adapterDisposed = false
+  let registeredByUs = new Set()
+
+  function disposeAdapterHandle(h) {
+    if (!h) return
+    try {
+      if (typeof h === 'function') h()
+      else if (typeof h.dispose === 'function') h.dispose()
+    } catch (err) {
+      if (logger && logger.debug) logger.debug('[dsh-subscriptions] dispose handle error: ' + (err && err.message || err))
+    }
+  }
+
+  const adapter = new SubscriptionAdapter({
+    listAccounts: (provider) => store.listAccounts(provider),
+    loadBlob: (ref) => store.loadBlob(ref),
+    ensureFresh: (provider, blob, ref) => store.ensureFresh(provider, blob, ref),
+    vendorConfig: (provider) => vendorConfig(provider, live()),
+    cooldownMs: () => live().cooldownMs,
+    switchAtRemaining: () => live().switchAtRemaining,
+    rememberCooldown: (ref, until, families) => store.rememberCooldown(ref, until, families),
+    rememberQuarantine: (ref, reason, until) => store.rememberQuarantine(ref, reason, until),
+    rememberQuota: (ref, snap) => store.rememberQuota(ref, snap),
+    getQuota: (ref) => store.getQuota(ref),
+    refreshUsage: (provider) => store.refreshUsage(provider),
+    saveBlob: (ref, blob) => store.saveBlob(ref, blob),
+    recordHistory,
+    fetchImpl: fetch,
+    fetchForRef,
+  })
+
+  async function* cascadeFallbackStream({ options, provider, err, visited = new Set() }) {
+    const cfg = live()
+    if (!cfg.cascadingFallback) throw err
+    const logged = await store.loggedInProviders()
+    const available = Object.keys(logged || {}).filter((p) => logged[p] && p !== provider)
+    visited.add(provider)
+    const nextVendor = resolveFallbackVendor(provider, available, cfg.cascadingChain, visited)
+    if (!nextVendor) throw err
+    visited.add(nextVendor)
+    const targetModel = mapFallbackModel(provider, options && options.model, nextVendor)
+    if (logger && logger.warn) {
+      logger.warn('[dsh-subscriptions] ' + provider + ': all accounts exhausted, cascading fallback to ' + nextVendor + '/' + targetModel)
+    }
+    yield* adapter.stream({ ...options, provider: nextVendor, model: targetModel }, visited)
+    try {
+      recordHistory({
+        provider: nextVendor,
+        ref: String(nextVendor).toUpperCase() + '_CASCADE_FALLBACK',
+        model: targetModel,
+        path: '/v1/chat/completions',
+        method: 'POST',
+        status: 200,
+        kind: 'cascade',
+      })
+    } catch { /* ignore cascade history recording error */ }
+  }
+
+  async function syncAdapter() {
+    if (adapterDisposed) return
+    const desired = await store.loggedInProviders()
+    const globalProviders = ctx.llm && typeof ctx.llm.listProviders === 'function'
+      ? ctx.llm.listProviders().map((p) => p.id)
+      : []
+    const globalSet = new Set(globalProviders)
+
+    const claimable = desired.filter((p) => !globalSet.has(p) || registeredByUs.has(p))
+    const skipped = desired.filter((p) => globalSet.has(p) && !registeredByUs.has(p))
+
+    if (skipped.length && logger && logger.info) {
+      logger.info(`[dsh-subscriptions] syncAdapter skipping already-bound providers: ${skipped.join(', ')}`)
+    }
+
+    if (!handle && claimable.length) {
+      handle = ctx.llm.registerAdapter(claimable, adapter)
+      registeredByUs = new Set(claimable)
+      return
+    }
+    if (!handle) {
+      registeredByUs.clear()
+      return
+    }
+    if (!claimable.length) {
+      disposeAdapterHandle(handle)
+      handle = undefined
+      registeredByUs.clear()
+      return
+    }
+    if (typeof handle.replace === 'function') {
+      try {
+        handle.replace(claimable)
+        registeredByUs = new Set(claimable)
+        return
+      } catch (err) {
+        if (logger && logger.warn) logger.warn('[dsh-subscriptions] handle.replace failed: ' + (err && err.message || err))
+        disposeAdapterHandle(handle)
+        handle = undefined
+        registeredByUs.clear()
+      }
+    } else {
+      disposeAdapterHandle(handle)
+      handle = undefined
+      registeredByUs.clear()
+    }
+
+    const currentGlobal = new Set((ctx.llm && typeof ctx.llm.listProviders === 'function' ? ctx.llm.listProviders() : []).map((p) => p.id))
+    const reClaimable = desired.filter((p) => !currentGlobal.has(p))
+    if (reClaimable.length) {
+      handle = ctx.llm.registerAdapter(reClaimable, adapter)
+      registeredByUs = new Set(reClaimable)
+    }
+  }
+
+  async function reconcileSlots() {
+    const api = getSettingsApi()
+    if (!api || typeof api.replace !== 'function') return
+    const creds = ctx.credentials
+    if (!creds || typeof creds.describe !== 'function') return
+
+    try {
+      const existing = normalizeSlots(live().slots)
+      const existingRefs = new Set(existing.map((s) => s.ref))
+      const candidateProviders = PROVIDERS.filter((p) => isProvider(p))
+      const candidates = []
+      for (const provider of candidateProviders) {
+        for (let index = 1; index <= 10; index++) {
+          const ref = oauthRef(provider, index)
+          if (!existingRefs.has(ref)) {
+            candidates.push({ provider, index, ref })
+          }
+        }
+      }
+
+      const additionResults = await Promise.all(
+        candidates.map(async ({ provider, index, ref }) => {
+          let d
+          try {
+            d = await creds.describe(credentialRef(ref))
+          } catch (err) {
+            if (logger && logger.debug) logger.debug(`[dsh-subscriptions reconcile] describe ${ref} error: ` + (err && err.message || err))
+            return null
+          }
+          if (d && d.configured) {
+            let label = d.label || ''
+            try {
+              const blob = await store.loadBlob(ref).catch(() => null)
+              if (blob && (blob.email || blob.label)) {
+                label = blob.email || blob.label || label
+              }
+            } catch (loadErr) {
+              if (logger && logger.debug) logger.debug(`[dsh-subscriptions reconcile] loadBlob ${ref} error: ` + (loadErr && loadErr.message || loadErr))
+            }
+            return { provider, index, label }
+          }
+          return null
+        })
+      )
+      const additions = additionResults.filter(Boolean)
+
+      if (!additions.length) return
+      if (logger && logger.info) {
+        logger.info(`[dsh-subscriptions reconcile] restoring orphaned vault slots: ${additions.map((a) => `${a.provider}#${a.index}`).join(', ')}`)
+      }
+      const currentSlots = Array.isArray(live().slots) ? live().slots : []
+      const newSlots = [...currentSlots, ...additions]
+      const parsed = Config({ ...live(), slots: stripLegacySlots(newSlots) })
+      await api.replace(parsed)
+      syncCustomVendors()
+      await syncAdapter()
+      refreshModels().catch((err) => {
+        if (logger && logger.debug) logger.debug('[dsh-subscriptions reconcile] refreshModels error: ' + (err && err.message || err))
+      })
+    } catch (e) {
+      if (logger && logger.warn) {
+        logger.warn('[dsh-subscriptions reconcile] failed: ' + (e && e.message || e))
+      }
+    }
+  }
+
+  let lastModelRefresh = 0
+  async function refreshModels() {
+    if (Date.now() - lastModelRefresh < 60 * 1000) return
+    lastModelRefresh = Date.now()
+    const providers = await store.loggedInProviders()
+    for (const provider of providers) {
+      try {
+        const slot = normalizeSlots(live().slots).find((x) => x.provider === provider)
+        if (!slot) continue
+        const blob = await store.loadBlob(slot.ref).catch(() => null)
+        if (!blob) continue
+        const fresh = await store.ensureFresh(provider, blob, slot.ref)
+        const cfg = vendorConfig(provider, live())
+        await getVendor(provider).listModels(fresh, cfg, fetch).catch(() => {})
+      } catch { /* best-effort */ }
+    }
+  }
+
+  function registerAdapterLifecycle() {
+    return ctx.effect(() => {
+      syncAdapter().catch((err) => {
+        if (logger && logger.debug) logger.debug('[dsh-subscriptions] syncAdapter initial error: ' + (err && err.message || err))
+      })
+      if (syncOllama) {
+        syncOllama().catch((err) => {
+          if (logger && logger.debug) logger.debug('[dsh-subscriptions] syncOllama initial error: ' + (err && err.message || err))
+        })
+      }
+      reconcileSlots().catch((err) => {
+        if (logger && logger.debug) logger.debug('[dsh-subscriptions] reconcileSlots effect error: ' + (err && err.message || err))
+      })
+
+      let retries = 0
+      let retryTimer
+      const scheduleRetry = () => {
+        if (adapterDisposed || retries >= 30) return
+        retryTimer = setTimeout(retrySync, 1000)
+        if (retryTimer && typeof retryTimer.unref === 'function') retryTimer.unref()
+      }
+      const retrySync = async () => {
+        if (adapterDisposed) return
+        try {
+          const loggedIn = await store.loggedInProviders()
+          if (!loggedIn.length) return
+          const registered = ctx.llm && typeof ctx.llm.listProviders === 'function'
+            ? ctx.llm.listProviders().map((p) => p.id)
+            : []
+          const regSet = new Set(registered)
+          const pending = loggedIn.filter((p) => !regSet.has(p))
+          if (pending.length === 0) return
+          retries += 1
+          await syncAdapter()
+          if (retries < 30) {
+            scheduleRetry()
+          }
+        } catch (err) {
+          if (logger && logger.debug) logger.debug('[dsh-subscriptions] retrySync error: ' + (err && err.message || err))
+          if (retries < 30) {
+            scheduleRetry()
+          }
+        }
+      }
+      scheduleRetry()
+
+      // #75: eager usage refresh at startup so the windows (5h/7d) land in the blob immediately
+      const eager = async () => {
+        try {
+          for (const slot of normalizeSlots(live().slots)) {
+            store.refreshUsage(slot.provider).catch((err) => {
+              if (logger && logger.debug) logger.debug('[dsh-subscriptions] eager usage error: ' + (err && err.message || err))
+            })
+          }
+        } catch (err) {
+          if (logger && logger.debug) logger.debug('[dsh-subscriptions] eager refresh error: ' + (err && err.message || err))
+        }
+      }
+      eager()
+
+      return () => {
+        adapterDisposed = true
+        if (retryTimer) clearTimeout(retryTimer)
+        if (handle) {
+          disposeAdapterHandle(handle)
+          handle = undefined
+          registeredByUs.clear()
+        }
+      }
+    }, 'dsh-subscriptions: llm adapter')
+  }
+
+  return {
+    adapter,
+    syncAdapter,
+    reconcileSlots,
+    refreshModels,
+    cascadeFallbackStream,
+    registerAdapterLifecycle,
+  }
+}

package/lib/adapter.js

@@ -37,7 +37,7 @@ export class SubscriptionAdapter extends LlmAdapter {
     return { id: provider, name: displayName(provider) }
   }
 
-  providerRetryPolicy(_provider) {
+  providerRetryPolicy() {
     return undefined
   }
 
@@ -67,11 +67,11 @@ export class SubscriptionAdapter extends LlmAdapter {
     return models
   }
 
-  imageRequestPricing(_provider, _model) {
+  imageRequestPricing() {
     return undefined
   }
 
-  async resolveModel(provider, model, _signal) {
+  async resolveModel(provider, model) {
     const rows = await this.listModels(provider)
     const found = rows.find((row) => row && row.id === model)
     if (found) {
@@ -127,11 +127,11 @@ export class SubscriptionAdapter extends LlmAdapter {
             try {
               const snap = quotaSnapshot(provider, res.headers, null, Date.now())
               if (snap && typeof deps.rememberQuota === "function") deps.rememberQuota(account.ref, snap)
-            } catch (err) { /* ignore quota capture failure */ }
+            } catch { /* ignore quota capture failure */ }
             if (!res.ok && res.clone) {
               try {
                 const txt = await res.clone().text()
-                let j=null; try { j = JSON.parse(txt) } catch (err) { j = null }
+                let j=null; try { j = JSON.parse(txt) } catch { j = null }
                 if (j) {
                   const b = parseBody(provider, j, Date.now())
                   if (b) {
@@ -139,7 +139,7 @@ export class SubscriptionAdapter extends LlmAdapter {
                     if (snap2) deps.rememberQuota(account.ref, snap2)
                   }
                 }
-              } catch (err) { /* ignore quota capture failure */ }
+              } catch { /* ignore quota capture failure */ }
             }
             return res
           }
@@ -169,7 +169,7 @@ export class SubscriptionAdapter extends LlmAdapter {
                   ms: Date.now() - t0,
                   kind: 'stream',
                 })
-              } catch (err) { /* ignore quota capture failure */ }
+              } catch { /* ignore quota capture failure */ }
             }
           } catch (err) {
             if (err && err.code === 'VALIDATION_REQUIRED' && err.validationUrl) {

package/lib/alerts.js

@@ -8,7 +8,7 @@ const DEDUP_WINDOW_MS = 10 * 60 * 1000 // 10 minutes cooldown per (ref + type)
 const alertBuffer = []
 const lastAlertTime = new Map()
 
-export function clearAlertsForTesting() {
+export function clearAlerts() {
   alertBuffer.length = 0
   lastAlertTime.clear()
 }
@@ -75,7 +75,7 @@ export async function dispatchWebhookAlert(alert, webhookUrl, fetchImpl = fetch)
       body: JSON.stringify(payload),
     })
     return res.ok
-  } catch (err) {
+  } catch {
     // Non-blocking fire-and-forget
     return false
   }

package/lib/backoff.js

@@ -3,7 +3,7 @@ export async function executeWithRetry(fn, {
   initialDelayMs = 200,
   maxDelayMs = 3000,
   factor = 2,
-  isRetryable = (err) => true
+  isRetryable = () => true
 } = {}) {
   let attempt = 0
   let delay = initialDelayMs