@goodandready/dsh-subscriptions 0.6.12 → 0.6.13

package/lib/index.js

@@ -20,6 +20,7 @@ import { createSubscriptionsService } from './subscriptions.js'
 import { encryptWithPassphrase, decryptWithPassphrase } from './crypto.js'
 import { quotaSnapshot } from './ratelimit.js'
 import { createAccountStore, normalizeSlots, vendorConfig } from './accounts.js'
+import { credentialRef } from '@deepseek-ai/dsh-credentials'
 import { startLoopback } from './loopback.js'
 import { OllamaAdapter, ollamaAlive, ollamaModels, ollamaBase } from './ollama.js'
 import { createResetCreditService } from './reset-credits.js'
@@ -57,6 +58,11 @@ export function apply(ctx, config) {
     const scope = sctx.settings.register(NS, Config, { base: config })
     settingsApi = scope
     getConfig = () => scope.get() ?? config
+    Promise.resolve().then(() => {
+      reconcileSlots().catch((err) => {
+        if (logger && logger.warn) logger.warn('[dsh-subscriptions] reconcileSlots initial error: ' + (err && err.message || err))
+      })
+    })
     sctx.effect(() => () => {
       settingsApi = undefined
       getConfig = () => config
@@ -243,23 +249,126 @@ export function apply(ctx, config) {
   })
 
   let handle
+  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))
+    }
+  }
+
   async function syncAdapter() {
-    const providers = await store.loggedInProviders()
-    if (!handle && providers.length) {
-      handle = ctx.llm.registerAdapter(providers, adapter)
+    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) return
-    if (!providers.length) {
-      try { handle() } catch { /* already gone */ }
+    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 = settingsApi
+    if (!api || typeof api.replace !== 'function') return
+    const creds = ctx.credentials
+    if (!creds || typeof creds.describe !== 'function') return
+
     try {
-      handle.replace(providers)
-    } catch {
-      try { handle() } catch { /* disposed */ }
-      handle = ctx.llm.registerAdapter(providers, adapter)
+      const existing = normalizeSlots(live().slots)
+      const existingRefs = new Set(existing.map((s) => s.ref))
+      const candidateProviders = PROVIDERS.filter((p) => isProvider(p))
+      const additions = []
+
+      for (const provider of candidateProviders) {
+        for (let index = 1; index <= 10; index++) {
+          const ref = oauthRef(provider, index)
+          if (existingRefs.has(ref)) continue
+          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))
+            continue
+          }
+          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))
+            }
+            additions.push({ provider, index, label })
+          }
+        }
+      }
+
+      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))
+      }
     }
   }
 
@@ -471,22 +580,67 @@ export function apply(ctx, config) {
   }
 
   ctx.effect(() => {
-    syncAdapter().catch(() => { /* first paint */ })
-    syncOllama().catch(() => { /* first paint */ })
+    syncAdapter().catch((err) => {
+      if (logger && logger.debug) logger.debug('[dsh-subscriptions] syncAdapter initial error: ' + (err && err.message || err))
+    })
+    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 (retries >= 30) return
+      retryTimer = setTimeout(retrySync, 1000)
+      if (retryTimer && typeof retryTimer.unref === 'function') retryTimer.unref()
+    }
+    const retrySync = async () => {
+      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
     // and the active subscription chip shows 5h/7d/... right away instead of waiting for probeInterval.
     const eager = async () => {
       try {
         for (const slot of normalizeSlots(live().slots)) {
-          store.refreshUsage(slot.provider).catch(() => {})
+          store.refreshUsage(slot.provider).catch((err) => {
+            if (logger && logger.debug) logger.debug('[dsh-subscriptions] eager usage error: ' + (err && err.message || err))
+          })
         }
-      } catch (err) { /* best-effort */ }
+      } catch (err) {
+        if (logger && logger.debug) logger.debug('[dsh-subscriptions] eager refresh error: ' + (err && err.message || err))
+      }
     }
     eager()
     return () => {
+      if (retryTimer) clearTimeout(retryTimer)
       if (handle) {
-        try { handle() } catch { /* ignore */ }
+        disposeAdapterHandle(handle)
         handle = undefined
+        registeredByUs.clear()
       }
     }
   }, 'dsh-subscriptions: llm adapter')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-subscriptions",
-  "version": "0.6.12",
+  "version": "0.6.13",
   "description": "Use ChatGPT Codex, Claude, Grok, Antigravity, Kimi, GLM, Cursor, Kiro, Copilot, Qwen, ERNIE, Spark, JetBrains, Perplexity, Replit, and Cody subscriptions as DeepSeek Harness LLM providers via OAuth.",
   "license": "MIT",
   "type": "module",