@goodandready/dsh-subscriptions 0.6.36 → 0.6.38

package/lib/accounts.js

@@ -13,7 +13,6 @@ export function normalizeSlots(slots) {
   const out = []
   const seen = new Set()
   for (const slot of Array.isArray(slots) ? slots : []) {
-    // User-editable config: a null or non-object entry must be skipped, not crash the plugin.
     if (!slot || typeof slot !== 'object') continue
     if (!isProvider(slot.provider)) continue
     const index = Number(slot.index)
@@ -22,10 +21,13 @@ export function normalizeSlots(slots) {
     if (seen.has(ref)) continue
     seen.add(ref)
     out.push({
+      ...slot,
       provider: slot.provider,
       index,
       label: String(slot.label || ''),
       ref,
+      ...(slot.proxyUrl ? { proxyUrl: String(slot.proxyUrl) } : {}),
+      ...(slot.expiresAt ? { expiresAt: Number(slot.expiresAt) } : {}),
     })
   }
   return out
@@ -94,16 +96,27 @@ export function createAccountStore({ credentials, getConfig, fetchImpl, fetchFor
   }
 
   async function saveBlob(ref, blob) {
+    if (!ref || typeof ref !== "string") throw new Error("invalid ref for saveBlob")
     const prev = writeQueues.get(ref) || Promise.resolve()
     const next = prev.catch(() => {}).then(async () => {
-      await credentials.set(credentialRef(ref), serializeBlob(blob))
+      try {
+        await credentials.set(credentialRef(ref), serializeBlob(blob))
+      } catch (err) {
+        const wrapErr = new Error(`failed to persist credentials for ${ref}: ${err && err.message || err}`)
+        wrapErr.code = "CREDENTIAL_SAVE_FAILED"
+        wrapErr.cause = err
+        throw wrapErr
+      }
     })
     writeQueues.set(ref, next)
     await next
   }
 
   async function clearRef(ref) {
-    await credentials.unset(credentialRef(ref))
+    if (!ref || typeof ref !== "string") return
+    try {
+      await credentials.unset(credentialRef(ref))
+    } catch { /* best-effort unset */ }
     cooldowns.delete(ref)
     quotas.delete(ref)
     quarantines.delete(ref)
@@ -202,6 +215,8 @@ export function createAccountStore({ credentials, getConfig, fetchImpl, fetchFor
   }
 
   async function ensureFresh(provider, blob, ref) {
+    if (!blob || typeof blob !== 'object') return blob
+    if (blob.apiKeyOnly || (blob.apiKey && (!blob.refreshToken || blob.refreshToken === blob.apiKey))) return blob
     if (!blob.refreshToken) return blob
     if (blob.expiresAt && blob.expiresAt - SKEW_MS > Date.now()) return blob
     const lockKey = ref || (provider + ":" + (blob.accountId || blob.email || (blob.refreshToken && blob.refreshToken.slice(-16)) || "anon"))

package/lib/adapter-manager.js

@@ -202,6 +202,8 @@ export function createAdapterManager({
   }
 
   let lastModelRefresh = 0
+  const providerModelCache = new Map()
+
   async function refreshModels() {
     if (Date.now() - lastModelRefresh < 60 * 1000) return
     lastModelRefresh = Date.now()
@@ -214,7 +216,10 @@ export function createAdapterManager({
         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(() => {})
+        const liveModels = await getVendor(provider).listModels(fresh, cfg, fetch).catch(() => null)
+        if (Array.isArray(liveModels) && liveModels.length) {
+          providerModelCache.set(provider, liveModels)
+        }
       } catch { /* best-effort */ }
     }
   }

package/lib/adapter.js

@@ -45,20 +45,24 @@ export class SubscriptionAdapter extends LlmAdapter {
   async listModels(provider) {
     const accounts = await this.deps.listAccounts(provider)
     const targetAccount = accounts.find((a) => a.hasToken)
-    if (!targetAccount) return []
-    const cfg = this.deps.vendorConfig(provider)
-    const fetchImpl = pickFetch(this.deps, targetAccount.ref)
     let models = null
-    try {
-      const blob = await this.deps.ensureFresh(
-        provider,
-        await this.deps.loadBlob(targetAccount.ref),
-        targetAccount.ref,
-      )
-      const live = await getVendor(provider).listModels(blob, cfg, fetchImpl)
-      if (Array.isArray(live) && live.length) models = live
-    } catch { /* use built-in catalog */ }
-    if (!models) models = modelCatalog(provider, cfg.models)
+    if (targetAccount) {
+      const cfg = this.deps.vendorConfig(provider)
+      const fetchImpl = pickFetch(this.deps, targetAccount.ref)
+      try {
+        const blob = await this.deps.ensureFresh(
+          provider,
+          await this.deps.loadBlob(targetAccount.ref),
+          targetAccount.ref,
+        )
+        const live = await getVendor(provider).listModels(blob, cfg, fetchImpl)
+        if (Array.isArray(live) && live.length) models = live
+      } catch { /* use built-in catalog */ }
+    }
+    if (!models) {
+      const cfg = this.deps.vendorConfig(provider)
+      models = modelCatalog(provider, cfg ? cfg.models : undefined)
+    }
     // #94: optionally hide test/preview/beta/legacy ids from the picker.
     if (typeof this.deps.hideDeprecatedModels === 'function' && this.deps.hideDeprecatedModels()) {
       models = models.filter((m) => !isDeprecatedId(String((m && m.id) || '')))

package/lib/blob.js

@@ -1,30 +1,33 @@
 function asString(value) {
-  return value == null ? '' : String(value)
+  return value == null ? "" : String(value)
 }
 
 export function serializeBlob(obj) {
-  const accessToken = asString(obj && obj.accessToken)
-  const refreshToken = asString(obj && obj.refreshToken)
-  if (!accessToken && !refreshToken) {
-    throw new Error('oauth blob needs accessToken or refreshToken')
+  if (!obj || typeof obj !== "object") throw new Error("invalid oauth blob")
+  const accessToken = asString(obj.accessToken)
+  const refreshToken = asString(obj.refreshToken)
+  if (!accessToken && !refreshToken && !obj.apiKey) {
+    throw new Error("oauth blob needs accessToken or refreshToken")
   }
   return JSON.stringify({
+    ...obj,
     accessToken,
     refreshToken,
-    expiresAt: Number(obj && obj.expiresAt) || 0,
-    label: asString(obj && obj.label),
-    email: asString(obj && obj.email),
-    accountId: asString(obj && obj.accountId),
-    projectId: asString(obj && obj.projectId),
-    ...(Array.isArray(obj && obj.usage) ? { usage: obj.usage } : {}),
-    ...((obj && obj.usageAt) ? { usageAt: Number(obj.usageAt) } : {}),
+    expiresAt: Number(obj.expiresAt) || 0,
+    label: asString(obj.label),
+    email: asString(obj.email),
+    accountId: asString(obj.accountId),
+    projectId: asString(obj.projectId),
+    ...(Array.isArray(obj.usage) ? { usage: obj.usage } : {}),
+    ...(obj.usageAt ? { usageAt: Number(obj.usageAt) } : {}),
   })
 }
 
 export function parseBlob(text) {
-  const obj = typeof text === 'string' ? JSON.parse(text) : text
-  if (!obj || typeof obj !== 'object') throw new Error('invalid oauth blob')
+  const obj = typeof text === "string" ? JSON.parse(text) : text
+  if (!obj || typeof obj !== "object") throw new Error("invalid oauth blob")
   return {
+    ...obj,
     accessToken: asString(obj.accessToken),
     refreshToken: asString(obj.refreshToken),
     expiresAt: Number(obj.expiresAt) || 0,
@@ -36,4 +39,3 @@ export function parseBlob(text) {
     ...(obj.usageAt ? { usageAt: Number(obj.usageAt) } : {}),
   }
 }
-

package/lib/config-schema.js

@@ -149,3 +149,55 @@ export function publicConfig(cfg) {
 
   return clone
 }
+
+export function restoreMaskedSecrets(incoming, existing) {
+  if (!incoming || typeof incoming !== "object") return incoming
+  if (!existing || typeof existing !== "object") return incoming
+
+  const out = { ...incoming }
+
+  for (const key of Object.keys(out)) {
+    if ((key.endsWith("ClientSecret") || key.endsWith("Secret")) && typeof out[key] === "string") {
+      if (out[key].includes("••••")) {
+        out[key] = existing[key] || ""
+      }
+    }
+  }
+
+  if (Array.isArray(out.slots) && Array.isArray(existing.slots)) {
+    out.slots = out.slots.map((s) => {
+      if (!s || typeof s !== "object" || typeof s.proxyUrl !== "string" || !s.proxyUrl.includes("••••")) return s
+      const match = existing.slots.find((e) => e && e.provider === s.provider && Number(e.index) === Number(s.index))
+      if (match && match.proxyUrl) {
+        return { ...s, proxyUrl: match.proxyUrl }
+      }
+      return s
+    })
+  }
+
+  if (Array.isArray(out.customVendors) && Array.isArray(existing.customVendors)) {
+    out.customVendors = out.customVendors.map((cv) => {
+      if (!cv || typeof cv !== "object") return cv
+      const match = existing.customVendors.find((e) => e && e.id === cv.id)
+      if (!match) return cv
+      const copy = { ...cv }
+      for (const f of ["apiKey", "token", "secret", "clientSecret"]) {
+        if (typeof copy[f] === "string" && copy[f].includes("••••")) {
+          copy[f] = match[f] || ""
+        }
+      }
+      if (copy.headers && typeof copy.headers === "object" && match.headers && typeof match.headers === "object") {
+        const h = { ...copy.headers }
+        for (const hk of Object.keys(h)) {
+          if (typeof h[hk] === "string" && h[hk].includes("••••")) {
+            h[hk] = match.headers[hk] || ""
+          }
+        }
+        copy.headers = h
+      }
+      return copy
+    })
+  }
+
+  return out
+}

package/lib/http.js

@@ -131,7 +131,49 @@ export function queryOf(req) {
 /**
  * Fetch with connect/overall timeout using AbortSignal.any.
  */
-export async function fetchWithTimeout(fetchImpl, url, init = {}, { timeoutMs = 30000 } = {}) {
+
+export function isSameOrigin(url1, url2) {
+  try {
+    const u1 = new URL(url1)
+    const u2 = new URL(url2)
+    return u1.origin.toLowerCase() === u2.origin.toLowerCase()
+  } catch {
+    return false
+  }
+}
+
+export function sanitizeRequestHeaders(url, init = {}, options = {}) {
+  const headers = { ...(init.headers || {}) }
+  if (!url) return headers
+  try {
+    const parsed = new URL(url)
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      delete headers.authorization
+      delete headers.Authorization
+      delete headers.cookie
+      delete headers.Cookie
+      return headers
+    }
+    const allowedOrigins = options.allowedOrigins || []
+    if (allowedOrigins.length > 0) {
+      const targetOrigin = parsed.origin.toLowerCase()
+      const isAllowed = allowedOrigins.some(o => {
+        try { return new URL(o).origin.toLowerCase() === targetOrigin } catch { return false }
+      })
+      if (!isAllowed) {
+        delete headers.authorization
+        delete headers.Authorization
+        delete headers.cookie
+        delete headers.Cookie
+      }
+    }
+  } catch {}
+  return headers
+}
+
+export async function fetchWithTimeout(fetchImpl, url, init = {}, { timeoutMs = 30000, allowedOrigins } = {}) {
+  const safeHeaders = sanitizeRequestHeaders(url, init, { allowedOrigins })
+  init = { ...init, headers: safeHeaders }
   const impl = fetchImpl || fetch
   if (!timeoutMs || timeoutMs <= 0) return impl(url, init)
   const controller = new AbortController()

package/lib/import-auth.js

@@ -232,7 +232,7 @@ export async function loadLocalCliBlob(provider, options = {}) {
       accessToken: tok,
       refreshToken: tok,
       githubToken: tok,
-      expiresAt: Date.now() + 30 * 86400 * 1000,
+      expiresAt: 0,
       email,
       label: email,
     }

package/lib/index.js

@@ -198,12 +198,16 @@ export function apply(ctx, rawConfig) {
     return proxyFetch(slot.proxyUrl)
   }
 
-  function redirectFor(ref, provider) {
+  function redirectFor(provider, ref, reqOrigin) {
+    if (typeof provider === "object" && provider !== null) {
+      const opts = provider
+      provider = opts.provider
+      ref = opts.ref
+      reqOrigin = opts.origin
+    }
     if (live().useWebCallback) {
-      const origin = (ctx.webServer && typeof ctx.webServer.url === 'string')
-        ? ctx.webServer.url
-        : ''
-      return webCallbackUri(origin, ref)
+      const origin = reqOrigin || ((ctx.webServer && typeof ctx.webServer.url === "string") ? ctx.webServer.url : "")
+      return webCallbackUri(origin)
     }
     return getVendor(provider).redirectUri(vendorConfig(provider, live()))
   }
@@ -359,20 +363,17 @@ export function apply(ctx, rawConfig) {
   }
 
   async function completeOAuth({ provider, index, code, state }) {
-    if (!isProvider(provider)) throw new Error('unknown provider')
-    const n = Number(index)
-    const ref = oauthRef(provider, n)
+    if (!state) throw new Error('missing oauth state')
     sweepPending(Date.now())
-    let row = state ? pending.get(state) : null
-    if (!row) {
-      for (const item of pending.values()) {
-        if (item.provider === provider && item.index === n) row = item
-      }
-    }
-    if (!row || !row.verifier) throw new Error('login session expired; start Connect again')
-    if (row.provider !== provider || row.index !== n) throw new Error('state does not match this account')
-    const cfg = { ...vendorConfig(provider, live()), redirectUri: row.redirectUri }
-    const blob = await getVendor(provider).exchangeCode(cfg, {
+    const row = pending.get(state)
+    if (!row || !row.verifier) throw new Error('login session expired or invalid state; start Connect again')
+    if (provider && row.provider !== provider) throw new Error('state provider mismatch')
+    if (index !== undefined && index !== null && Number(index) !== row.index) throw new Error('state index mismatch')
+    const actualProvider = row.provider
+    const n = row.index
+    const ref = oauthRef(actualProvider, n)
+    const cfg = { ...vendorConfig(actualProvider, live()), redirectUri: row.redirectUri }
+    const blob = await getVendor(actualProvider).exchangeCode(cfg, {
       verifier: row.verifier,
       challenge: row.challenge,
       state: row.state,
@@ -384,7 +385,7 @@ export function apply(ctx, rawConfig) {
     pending.delete(row.state)
     await syncAdapter()
     refreshModels().catch(() => {})
-    return { ref, label: pmL(blob.label || blob.email) || displayName(provider) }
+    return { ref, label: pmL(blob.label || blob.email) || displayName(actualProvider) }
   }
 
   // Privacy masking

package/lib/routes/accounts.js

@@ -4,7 +4,7 @@ import { Config, plainConfig, publicConfig } from '../config-schema.js'
 import { decryptWithPassphrase, encryptWithPassphrase } from '../crypto.js'
 import { isTrustedSettingsRequest, queryOf, readBody, safeJsonHandler, writeJson } from '../http.js'
 import { discoverLocalCliSessions, loadLocalCliBlob } from '../import-auth.js'
-import { isProvider, oauthRef } from '../refs.js'
+import { isProvider, oauthRef, parseOauthRef } from '../refs.js'
 
 export function registerAccountsRoutes(ctx, state) {
   const {
@@ -143,8 +143,13 @@ export function registerAccountsRoutes(ctx, state) {
       } catch {
         body = null
       }
-      if (!body || !body.provider) {
-        writeJson(res, 400, { ok: false, error: { code: 'bad_request', message: 'missing provider' } })
+      if (!body || !body.provider || !isProvider(body.provider)) {
+        writeJson(res, 400, { ok: false, error: { code: 'bad_request', message: 'unknown or missing provider' } })
+        return
+      }
+      const idxNum = Number(body.index) || 1
+      if (!Number.isInteger(idxNum) || idxNum < 1 || idxNum > 99) {
+        writeJson(res, 400, { ok: false, error: { code: 'bad_request', message: 'invalid account index' } })
         return
       }
       try {
@@ -164,7 +169,7 @@ export function registerAccountsRoutes(ctx, state) {
           syncCustomVendors()
         }
         const slot = normalizeSlots(live().slots).find((s) => s.provider === prov && s.index === idx)
-        const ref = slot ? slot.ref : `${prov.toUpperCase()}_OAUTH_${idx}`
+        const ref = slot ? slot.ref : oauthRef(prov, idx)
         await store.saveBlob(ref, blob)
         await syncAdapter()
         refreshModels().catch(() => {})
@@ -201,11 +206,12 @@ export function registerAccountsRoutes(ctx, state) {
         writeJson(res, 400, { ok: false, error: { code: 'json', message: 'invalid json' } })
         return
       }
-      const passphrase = payload.passphrase
-      if (!passphrase || typeof passphrase !== 'string') {
-        writeJson(res, 400, { ok: false, error: { code: 'passphrase', message: 'passphrase is required' } })
+      const passphrase = String(payload.passphrase || '').trim()
+      if (!passphrase || passphrase.length < 12) {
+        writeJson(res, 400, { ok: false, error: { code: 'passphrase', message: 'passphrase must be at least 12 characters' } })
         return
       }
+      const algorithm = payload.algorithm === 'pbkdf2' || payload.algorithm === 'scrypt-v2' || payload.algorithm === 'scrypt-hardened' ? payload.algorithm : 'scrypt'
       try {
         const accounts = []
         for (const slot of normalizeSlots(live().slots)) {
@@ -219,7 +225,7 @@ export function registerAccountsRoutes(ctx, state) {
           return
         }
         const bundle = JSON.stringify({ v: 1, exportedAt: Date.now(), accounts })
-        const encrypted = encryptWithPassphrase(bundle, passphrase)
+        const encrypted = encryptWithPassphrase(bundle, passphrase, { algorithm })
         writeJson(res, 200, { ok: true, payload: encrypted, count: accounts.length })
       } catch (e) {
         writeJson(res, 500, { ok: false, error: { code: 'export', message: String(e && e.message || e) } })
@@ -265,6 +271,7 @@ export function registerAccountsRoutes(ctx, state) {
       let imported = 0
       for (const row of bundle.accounts) {
         try {
+          if (!row || typeof row.ref !== 'string' || !parseOauthRef(row.ref) || !row.blob) continue
           await store.saveBlob(row.ref, row.blob)
           imported++
         } catch { /* skip broken */ }
@@ -301,6 +308,10 @@ export function registerAccountsRoutes(ctx, state) {
         writeJson(res, 400, { ok: false, error: { code: 'provider', message: 'unknown provider' } })
         return
       }
+      if (!Number.isInteger(index) || index < 1 || index > 99) {
+        writeJson(res, 400, { ok: false, error: { code: 'index', message: 'account index must be an integer between 1 and 99' } })
+        return
+      }
       if (!refreshToken && !apiKey) {
         writeJson(res, 400, { ok: false, error: { code: 'token', message: 'refreshToken or apiKey is required' } })
         return

package/lib/routes/oauth.js

@@ -39,7 +39,7 @@ export function registerOauthRoutes(ctx, state) {
         return
       }
       const origin = requestOrigin(req)
-      const redirectUri = redirectFor(provider, live(), origin)
+      const redirectUri = redirectFor(provider, `${provider}:${index}`, origin)
       const pkce = await createPkce()
       pending.set(pkce.state, {
         provider,

package/lib/routes/status.js

@@ -1,6 +1,7 @@
+// #374: Sensitive GET routes protected by same-origin check
 import { getRecentAlerts, clearAlerts } from '../alerts.js'
 import { normalizeSlots, vendorConfig } from '../accounts.js'
-import { Config, plainConfig, publicConfig } from '../config-schema.js'
+import { Config, plainConfig, publicConfig, restoreMaskedSecrets } from '../config-schema.js'
 import { isTrustedSettingsRequest, queryOf, readBody, safeJsonHandler, writeJson } from '../http.js'
 import { quotaSnapshot } from '../ratelimit.js'
 import { PROVIDERS, displayName, droppedCredentialRefs, isProvider, oauthRef } from '../refs.js'
@@ -64,7 +65,8 @@ export function registerStatusRoutes(ctx, state) {
         return
       }
       // #379: revision conflict detection (CAS)
-      const baseRev = payload?.revision != null ? Number(payload.revision) : (req.headers?.['if-match'] ? Number(req.headers['if-match']) : null)
+      const rawRev = payload?.revision ?? payload?.config?.revision ?? req.headers?.['if-match']
+      const baseRev = rawRev != null ? Number(rawRev) : null
       if (baseRev != null && !Number.isNaN(baseRev) && baseRev !== currentRevision) {
         writeJson(res, 409, {
           ok: false,
@@ -79,13 +81,16 @@ export function registerStatusRoutes(ctx, state) {
 
       if (payload && typeof payload.config === 'object') payload = payload.config
       try {
+        payload = restoreMaskedSecrets(payload, live())
         if (Array.isArray(payload.slots)) payload.slots = stripLegacySlots(payload.slots)
         const parsed = plainConfig(Config(payload))
         const dropped = droppedCredentialRefs(live().slots, parsed.slots)
         await getSettingsApi().replace(parsed)
         currentRevision++
         syncCustomVendors()
-        for (const ref of dropped) await store.clearRef(ref)
+        for (const ref of dropped) {
+          try { await store.clearRef(ref) } catch { /* best-effort cleanup */ }
+        }
         await syncAdapter()
         writeJson(res, 200, await configResponse())
       } catch (e) {

package/lib/vendors/claude.js

@@ -1,3 +1,4 @@
+import { fetchWithTimeout } from '../http.js'
 import { buildAuthorizeUrl } from '../oauth.js'
 import { anthropicPayload, modelCatalog } from '../messages.js'
 import { jsonTokenRequest, anthropicStream, httpError, tokenBlobFromOAuth, readJson } from '../wire.js'
@@ -119,15 +120,50 @@ export async function refresh(cfg, blob, fetchImpl) {
   return decorate(tokenBlobFromOAuth(json, { label: blob.label, email: blob.email }), fetchImpl)
 }
 
-export async function listModels(blob, cfg) {
-  const raw = cfg.models && cfg.models.length ? cfg.models : defaults().models
-  const entries = raw.map((entry) => {
-    const model = typeof entry === 'string' ? { id: entry, name: entry } : { ...entry }
+export async function listModels(blob, cfg, fetchImpl) {
+  const impl = fetchImpl || fetch
+  const rawDefault = (cfg && cfg.models && cfg.models.length) ? cfg.models : defaults().models
+  const defaultCatalog = modelCatalog(id, rawDefault.map((entry) => {
+    const model = typeof entry === "string" ? { id: entry, name: entry } : { ...entry }
     const levels = effortLevelsForModel(model.id || model.name)
     if (!levels) return model
     return { ...model, reasoning: { efforts: levels.map((level) => ({ id: level, name: level })) } }
-  })
-  return modelCatalog(id, entries)
+  }))
+
+  if (!blob || !blob.accessToken) return defaultCatalog
+
+  try {
+    const headers = {
+      "Accept": "application/json",
+      "anthropic-version": "2023-06-01",
+    }
+    if (blob.accessToken.startsWith("sk-ant-")) {
+      headers["x-api-key"] = blob.accessToken
+    } else {
+      headers["Authorization"] = `Bearer ${blob.accessToken}`
+    }
+
+    const res = await fetchWithTimeout(impl, "https://api.anthropic.com/v1/models", { headers }, { timeoutMs: 15000 })
+    if (!res.ok) return defaultCatalog
+    const json = await readJson(res)
+    const items = json && json.data
+    if (!Array.isArray(items) || !items.length) return defaultCatalog
+    const rows = []
+    for (const item of items) {
+      const modelId = item.id || item.display_name
+      if (!modelId) continue
+      const levels = effortLevelsForModel(modelId)
+      rows.push({
+        id: modelId,
+        name: item.display_name || modelId,
+        ...(levels ? { reasoning: { efforts: levels.map((level) => ({ id: level, name: level })) } } : {}),
+      })
+    }
+    if (!rows.length) return defaultCatalog
+    return modelCatalog(id, rows)
+  } catch {
+    return defaultCatalog
+  }
 }
 
 // Advertise adaptive thinking + effort only for models whose capability table

package/lib/vendors/copilot.js

@@ -1,5 +1,6 @@
 import { LlmError } from "@deepseek-ai/dsh-llm"
-import { openaiMessages, openaiTools } from "../messages.js"
+import { openaiMessages, openaiTools, modelCatalog } from "../messages.js"
+import { fetchWithTimeout } from "../http.js"
 import { openaiChatStream, readJson, httpError } from "../wire.js"
 import { asUsageSnapshot } from "../usage.js"
 
@@ -68,8 +69,50 @@ export function authorizeUrl() {
   return "https://github.com/login/device"
 }
 
-export async function listModels() {
-  return COPILOT_MODELS
+export async function listModels(blob, cfg, fetchImpl) {
+  const impl = fetchImpl || fetch
+  const fallback = modelCatalog(id, (cfg && cfg.models) || COPILOT_MODELS)
+  if (!blob) return fallback
+  const githubToken = blob.refreshToken || blob.githubToken
+  let copilotToken = blob.accessToken
+  try {
+    if ((!copilotToken || !blob.expiresAt || blob.expiresAt < Date.now() + 60000) && githubToken) {
+      const exchange = await exchangeCopilotToken(githubToken, impl)
+      if (exchange && exchange.token) {
+        copilotToken = exchange.token
+        blob.accessToken = exchange.token
+        if (exchange.expires_at) blob.expiresAt = exchange.expires_at * 1000
+      }
+    }
+    if (!copilotToken) return fallback
+    const res = await fetchWithTimeout(impl, "https://api.githubcopilot.com/models", {
+      headers: {
+        Authorization: `Bearer ${copilotToken}`,
+        Accept: "application/json",
+        "User-Agent": "GitHubCopilotChat/0.24.0",
+      },
+    }, { timeoutMs: 15000 })
+    if (!res.ok) return fallback
+    const json = await readJson(res)
+    const items = json && (json.data || json.models || json)
+    if (!Array.isArray(items) || !items.length) return fallback
+    const rows = []
+    for (const item of items) {
+      const modelId = item.id || item.name
+      if (!modelId) continue
+      if (item.capabilities && item.capabilities.type && item.capabilities.type !== "chat") continue
+      rows.push({
+        id: modelId,
+        name: item.name || modelId,
+        ...(item.capabilities && item.capabilities.limits && item.capabilities.limits.max_prompt_tokens ? { contextWindow: item.capabilities.limits.max_prompt_tokens } : {}),
+        ...(item.capabilities && item.capabilities.supports && item.capabilities.supports.vision ? { inputModalities: ["text", "image"] } : {}),
+      })
+    }
+    if (!rows.length) return fallback
+    return modelCatalog(id, rows)
+  } catch {
+    return fallback
+  }
 }
 
 export function getTelemetryHeaders(sessionId) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-subscriptions",
-  "version": "0.6.36",
+  "version": "0.6.38",
   "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",