@goodandready/dsh-subscriptions 0.7.5 → 0.7.6

package/bin/dsh-subscriptions.mjs

@@ -1,11 +1,12 @@
 #!/usr/bin/env node
 import process from 'node:process'
 import { pathToFileURL } from 'node:url'
+import { readFile } from 'node:fs/promises'
 
 export function parseArgs(argv) {
   const args = Array.isArray(argv) ? argv.slice() : []
   const command = args.shift() || 'status'
-  const options = { command, csv: false, json: false, type: 'accounts', sessionId: '', mode: 'fast', help: false, setKey: '', setValue: '' }
+  const options = { command, csv: false, json: false, type: 'accounts', sessionId: '', mode: 'fast', help: false, setKey: '', setValue: '', packAction: '', packFile: '' }
   for (let i = 0; i < args.length; i += 1) {
     const arg = args[i]
     if (arg === '--csv') options.csv = true
@@ -15,6 +16,8 @@ export function parseArgs(argv) {
     else if (arg === '--session') options.sessionId = args[++i] || ''
     else if (command === 'set' && !options.setKey) options.setKey = arg
     else if (command === 'set') options.setValue = arg
+    else if (command === 'packs' && arg === 'add') options.packAction = 'add'
+    else if (command === 'packs' && options.packAction === 'add' && !options.packFile) options.packFile = arg
     else if (command === 'fast' && !options.sessionId) options.sessionId = arg
     else if (command === 'fast') options.mode = arg === 'standard' || arg === 'off' ? 'standard' : 'fast'
   }
@@ -67,9 +70,60 @@ export function buildRequest(options, env = process.env) {
   }
   if (options.command === 'config') return { url: base + '/config', init: { method: 'GET', headers } }
   if (options.command === 'sources') return { url: base + '/sources', init: { method: 'GET', headers } }
+  if (options.command === 'packs') return { url: base + '/config', init: { method: 'GET', headers } }
+  if (options.command === 'diagnostics') return { url: base + '/diagnostics', init: { method: 'GET', headers } }
   throw new Error('unknown command: ' + options.command)
 }
 
+export function doctorFailed(payload) {
+  const diag = (payload && payload.diagnostics) || {}
+  const report = diag.report || {}
+  const errors = Array.isArray(report.recentErrors) ? report.recentErrors.length : 0
+  const conflicts = Array.isArray(diag.conflicts) ? diag.conflicts.length : 0
+  return errors > 0 || conflicts > 0
+}
+
+export function formatDoctor(payload) {
+  const diag = (payload && payload.diagnostics) || {}
+  const report = diag.report || {}
+  const sources = (payload && payload.sources) || {}
+  const errors = Array.isArray(report.recentErrors) ? report.recentErrors.length : 0
+  const conflicts = Array.isArray(diag.conflicts) ? diag.conflicts.length : 0
+  const kr = sources.keyRotation || {}
+  const lines = []
+  lines.push('doctor: ' + (doctorFailed(payload) ? 'degraded' : 'ok'))
+  lines.push('errors: ' + errors + ' conflicts: ' + conflicts)
+  lines.push('key-rotation: ' + (kr.available ? (kr.healthyKeys + '/' + kr.totalKeys + ' healthy keys') : ('unavailable' + (kr.reason ? ' (' + kr.reason + ')' : ''))))
+  for (const row of (sources.providers || [])) lines.push(row.provider + ': ' + (row.selected || 'none'))
+  return lines.join('\n')
+}
+
+export function sanitizePack(pack) {
+  if (!pack || typeof pack !== 'object') return pack
+  const copy = JSON.parse(JSON.stringify(pack))
+  if (copy.clientSecret) copy.clientSecret = '••••••'
+  if (copy.headers && typeof copy.headers === 'object') {
+    copy.headers = Object.fromEntries(Object.keys(copy.headers).map((key) => [key, '••••••']))
+  }
+  return copy
+}
+
+export function formatPacks(packs) {
+  return JSON.stringify((Array.isArray(packs) ? packs : []).map(sanitizePack), null, 2) + '\\n'
+}
+
+export function mergeProviderPack(packs, pack) {
+  const list = (Array.isArray(packs) ? packs : []).filter((p) => p && p.id !== pack.id)
+  return [...list, pack]
+}
+
+export function buildValidatePackRequest(pack, env = process.env) {
+  const base = String(env.DSH_SUBS_URL || 'http://127.0.0.1:3080/dsh-subscriptions').replace(/\/$/, '')
+  const headers = { Accept: 'application/json', 'Content-Type': 'application/json' }
+  if (env.DSH_AUTH_TOKEN) headers.Authorization = 'Bearer ' + env.DSH_AUTH_TOKEN
+  return { url: base + '/provider-packs/validate', init: { method: 'POST', headers, body: JSON.stringify({ pack }) } }
+}
+
 export function formatSources(payload) {
   const lines = []
   const kr = payload && payload.keyRotation
@@ -98,6 +152,41 @@ export function buildSetRequest(options, configPayload, env = process.env) {
 export async function run(argv = process.argv.slice(2), env = process.env, fetchImpl = fetch) {
   const options = parseArgs(argv)
   if (options.help) return { help: true }
+  if (options.command === 'doctor') {
+    const diagReq = buildRequest({ command: 'diagnostics' }, env)
+    const srcReq = buildRequest({ command: 'sources' }, env)
+    const [diagRes, srcRes] = await Promise.all([fetchImpl(diagReq.url, diagReq.init), fetchImpl(srcReq.url, srcReq.init)])
+    const diagText = await diagRes.text()
+    const srcText = await srcRes.text()
+    if (!diagRes.ok) throw new Error('HTTP ' + diagRes.status + ': ' + diagText.slice(0, 500))
+    if (!srcRes.ok) throw new Error('HTTP ' + srcRes.status + ': ' + srcText.slice(0, 500))
+    const payload = { diagnostics: JSON.parse(diagText || '{}'), sources: JSON.parse(srcText || '{}') }
+    return {
+      text: options.json ? JSON.stringify(payload, null, 2) + '\n' : formatDoctor(payload),
+      contentType: options.json ? 'application/json' : 'text/plain',
+      code: doctorFailed(payload) ? 1 : 0,
+    }
+  }
+  if (options.command === 'packs' && options.packAction === 'add') {
+    if (!options.packFile) throw new Error('packs add requires a JSON file')
+    const pack = JSON.parse(await readFile(options.packFile, 'utf8'))
+    const validate = buildValidatePackRequest(pack.pack || pack, env)
+    const checked = await fetchImpl(validate.url, validate.init)
+    const checkedText = await checked.text()
+    if (!checked.ok) throw new Error('invalid pack: ' + checkedText.slice(0, 500))
+    const current = await fetchImpl(buildRequest({ command: 'config' }, env).url, buildRequest({ command: 'config' }, env).init)
+    const currentText = await current.text()
+    if (!current.ok) throw new Error('HTTP ' + current.status + ': ' + currentText.slice(0, 500))
+    const payload = JSON.parse(currentText || '{}')
+    const nextConfig = Object.assign({}, payload.config, {
+      providerPacks: mergeProviderPack(payload.config && payload.config.providerPacks, pack.pack || pack),
+    })
+    const put = buildSetRequest({ setKey: 'providerPacks', setValue: JSON.stringify(nextConfig.providerPacks) }, { config: nextConfig, revision: payload.revision }, env)
+    const saved = await fetchImpl(put.url, put.init)
+    const savedText = await saved.text()
+    if (!saved.ok) throw new Error('HTTP ' + saved.status + ': ' + savedText.slice(0, 500))
+    return { text: 'saved provider pack ' + ((pack.pack && pack.pack.id) || pack.id || ''), contentType: 'text/plain' }
+  }
   let request = buildRequest(options.command === 'set' ? { ...options, command: 'config' } : options, env)
   if (options.command === 'set') {
     const current = await fetchImpl(request.url, request.init)
@@ -108,6 +197,12 @@ export async function run(argv = process.argv.slice(2), env = process.env, fetch
   const res = await fetchImpl(request.url, request.init)
   const text = await res.text()
   if (!res.ok) throw new Error('HTTP ' + res.status + ': ' + text.slice(0, 500))
+  if (options.command === 'packs' && options.packAction !== 'add') {
+    try {
+      const payload = JSON.parse(text || '{}')
+      return { text: formatPacks((payload.config && payload.config.providerPacks) || []), contentType: 'application/json' }
+    } catch { /* fall back to raw */ }
+  }
   if (options.command === 'sources' && !options.json) {
     try { return { text: formatSources(JSON.parse(text || '{}')), contentType: 'text/plain' } } catch { /* fall back to raw */ }
   }
@@ -117,10 +212,11 @@ export async function run(argv = process.argv.slice(2), env = process.env, fetch
 async function main() {
   const result = await run()
   if (result.help) {
-    process.stdout.write('Usage: dsh-subscriptions <status|usage|fast|config|set|sources> [options]\n  usage --csv --type accounts|calls\n  fast <session> [fast|standard]\n  config\n  set <dot.path> <value>\n  sources [--json]\n')
+    process.stdout.write('Usage: dsh-subscriptions <status|usage|fast|config|set|sources|packs|doctor> [options]\n  usage --csv --type accounts|calls\n  fast <session> [fast|standard]\n  config\n  set <dot.path> <value>\n  sources [--json]\n  packs\n  packs add <file.json>\n  doctor [--json]\n')
     return
   }
   process.stdout.write(result.text.endsWith('\n') ? result.text : result.text + '\n')
+  if (result.code) process.exitCode = result.code
 }
 
 if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {

package/lib/alerts.js

@@ -13,6 +13,11 @@ try {
 // and webhook dispatch (e.g. Telegram/Discord or external monitoring).
 
 const MAX_ALERTS = 100
+let defaultWebhookSecret = ''
+
+export function setWebhookSecret(secret) {
+  defaultWebhookSecret = String(secret || '')
+}
 const DEDUP_WINDOW_MS = 10 * 60 * 1000 // 10 minutes cooldown per (ref + type)
 
 const alertBuffer = []
@@ -93,7 +98,9 @@ export async function dispatchNotificationDigest(alerts, webhookUrl, fetchImpl =
 }
 
 async function dispatchNotification(body, webhookUrl, fetchImpl, options) {
-  const { secret = '', retries = 1, timeoutMs = 5000, sleep } = options || {}
+  const opts = options || {}
+  const { retries = 1, timeoutMs = 5000, sleep } = opts
+  const secret = opts.secret == null ? defaultWebhookSecret : opts.secret
   const payload = { ...body, source: 'dsh-subscriptions', sentAt: new Date().toISOString() }
   const raw = JSON.stringify(payload)
   const headers = {

package/lib/client.js

@@ -1842,6 +1842,7 @@ window.__ModuleLoader__.load({
           ),
           h('div', { className: 'dsub-sub' }, 'Floating capsule can be dragged; docked stays bottom-right.'),
           h(SourcesPanel, { t }),
+          h(ProviderPacksPanel),
 
           h('div', { className: 'dsub-row' },
             h('span', { className: 'dsub-h' }, t('composerQuota')),
@@ -1872,6 +1873,40 @@ window.__ModuleLoader__.load({
           ),
           h('div', { className: 'dsub-sub' },
             t('expiryNotifyDaysHint')),
+          h('div', { className: 'dsub-row' },
+            h('span', { className: 'dsub-h' }, 'Webhook URL'),
+            h('input', {
+              type: 'url',
+              className: 'dsub-inp',
+              placeholder: 'https://hooks.example/…',
+              value: draft.webhookUrl || '',
+              onChange: (e) => setDraft((d) => Object.assign({}, d, { webhookUrl: e.target.value })),
+            }),
+          ),
+          h('div', { className: 'dsub-sub' }, 'Signed POST target for quota, session and billing alerts.'),
+          h('div', { className: 'dsub-row' },
+            h('span', { className: 'dsub-h' }, 'Webhook secret'),
+            h('input', {
+              type: 'password',
+              className: 'dsub-inp',
+              autoComplete: 'new-password',
+              value: draft.webhookSecret || '',
+              onChange: (e) => setDraft((d) => Object.assign({}, d, { webhookSecret: e.target.value })),
+            }),
+          ),
+          h('div', { className: 'dsub-row' },
+            h('span', { className: 'dsub-h' }, 'Digest interval (hours)'),
+            h('input', {
+              type: 'number',
+              className: 'dsub-inp',
+              style: { width: '80px', minWidth: '80px' },
+              min: 0,
+              max: 168,
+              value: draft.digestIntervalHours != null ? draft.digestIntervalHours : 0,
+              onChange: (e) => setDraft((d) => Object.assign({}, d, { digestIntervalHours: Number(e.target.value) || 0 })),
+            }),
+          ),
+          h('div', { className: 'dsub-sub' }, '0 disables digests. Requires a Webhook URL.'),
           ),
           h('details', { className: 'dsub-group', open: true },
             h('summary', { className: 'dsub-groupHead' }, '🚦 ' + t('groupQueue')),
@@ -3655,6 +3690,79 @@ window.__ModuleLoader__.load({
       )
     }
 
+    // #724: provider pack manager. Displays ids/models only; headers are masked.
+    function ProviderPacksPanel() {
+      const [state, setState] = React.useState({ packs: [], text: '', message: '', error: null, busy: false })
+      const publicPack = (pack) => {
+        const copy = Object.assign({}, pack)
+        if (copy.clientSecret) copy.clientSecret = '••••'
+        if (copy.headers && typeof copy.headers === 'object') {
+          copy.headers = Object.fromEntries(Object.keys(copy.headers).map((key) => [key, '••••']))
+        }
+        return copy
+      }
+      const pull = () => {
+        fetch('/dsh-subscriptions/config', { cache: 'no-store' })
+          .then((res) => res.json())
+          .then((cfg) => setState((st) => Object.assign({}, st, { packs: (cfg.config && cfg.config.providerPacks) || [] })))
+          .catch((err) => setState((st) => Object.assign({}, st, { error: String(err && err.message || err) })))
+      }
+      React.useEffect(() => { pull() }, [])
+      const parse = () => {
+        const raw = JSON.parse(state.text || '{}')
+        return raw && raw.pack ? raw.pack : raw
+      }
+      const validate = (pack) => fetch('/dsh-subscriptions/provider-packs/validate', {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ pack }),
+      }).then(async (res) => {
+        const data = await res.json()
+        if (!res.ok || !data.ok) throw new Error((data.error && data.error.message) || ('HTTP ' + res.status))
+        return data.pack
+      })
+      const save = () => {
+        setState((st) => Object.assign({}, st, { busy: true, message: '', error: null }))
+        Promise.resolve().then(parse)
+          .then(async (pack) => {
+            const checked = await validate(pack)
+            const cfg = await fetch('/dsh-subscriptions/config', { cache: 'no-store' }).then((res) => res.json())
+            const packs = ((cfg.config && cfg.config.providerPacks) || []).filter((p) => p && p.id !== pack.id)
+            packs.push(pack)
+            const res = await fetch('/dsh-subscriptions/config', {
+              method: 'PUT',
+              headers: { 'content-type': 'application/json' },
+              body: JSON.stringify({ config: Object.assign({}, cfg.config, { providerPacks: packs }), revision: cfg.revision }),
+            })
+            if (!res.ok) throw new Error('HTTP ' + res.status)
+            setState((st) => Object.assign({}, st, { packs, busy: false, message: 'saved ' + checked.id, text: '' }))
+          })
+          .catch((err) => setState((st) => Object.assign({}, st, { busy: false, error: String(err && err.message || err) })))
+      }
+      const exportPacks = () => setState((st) => Object.assign({}, st, { text: JSON.stringify(st.packs.map(publicPack), null, 2), message: 'exported' }))
+      return h('div', { className: 'dsub-section-card' },
+        h('div', { className: 'dsub-section-title' }, 'Provider packs', h('button', { type: 'button', className: 'dsub-mini', onClick: pull }, '↻')),
+        h('div', { className: 'dsub-section-desc' }, 'Add an OpenAI-Responses-compatible provider as a JSON manifest. Headers are masked in the editor.'),
+        state.packs.length ? state.packs.map((pack) => h('div', { className: 'dsub-row', key: pack.id },
+          h('span', { className: 'dsub-h' }, pack.id),
+          h('span', { className: 'dsub-dim' }, (pack.displayName || '') + ' · ' + ((pack.models || []).length) + ' models'),
+        )) : h('div', { className: 'dsub-dim' }, 'No packs yet.'),
+        h('textarea', {
+          className: 'dsub-inp',
+          style: { width: '100%', minHeight: 120, fontFamily: 'ui-monospace,monospace', padding: 8 },
+          value: state.text,
+          placeholder: '{"id":"acme","displayName":"Acme AI","authUrl":"https://…","tokenUrl":"https://…","baseUrl":"https://…","clientId":"…","models":[{"id":"acme-1"}]}',
+          onChange: (e) => setState((st) => Object.assign({}, st, { text: e.target.value, message: '', error: null })),
+        }),
+        h('div', { className: 'dsub-row' },
+          h('button', { type: 'button', className: 'dsub-mini', disabled: state.busy, onClick: save }, state.busy ? '…' : 'Validate & save'),
+          h('button', { type: 'button', className: 'dsub-mini', onClick: exportPacks }, 'Export'),
+        ),
+        state.message ? h('div', { className: 'dsub-ok' }, state.message) : null,
+        state.error ? h('div', { className: 'dsub-bad' }, state.error) : null,
+      )
+    }
+
     // #713: read-only source chain panel. Never renders key values.
     function SourcesPanel() {
       const [state, setState] = React.useState({ loading: true, data: null, error: null })

package/lib/config-schema.js

@@ -157,6 +157,10 @@ export const Config = z.object({
     .description('#349 Custom cross-vendor fallback chains (e.g. { claude: ["copilot", "cursor"] }).'),
   webhookUrl: z.string().volatile().default('')
     .description('#351 External webhook URL to receive quota and session alerts (JSON POST).'),
+  webhookSecret: z.string().role('secret').default('')
+    .description('#720 HMAC-SHA256 secret used to sign webhook payloads.'),
+  digestIntervalHours: z.number().volatile().default(0)
+    .description('#720 Send an alert digest every N hours (0 disables digests).'),
   alertThresholds: z.array(z.number()).volatile().default([80, 90, 95])
     .description('#351 Quota usage percentage thresholds for firing alerts.'),
   enableToasts: z.boolean().volatile().default(true)

package/lib/index.js

@@ -28,7 +28,8 @@ import { createAccountsView } from './accounts-view.js'
 import { inspectScopes } from './scope-inspector.js'
 import { createAdapterManager } from './adapter-manager.js'
 import { pickAccount, isAuthError } from './rotate.js'
-import { notifySessionExpired } from './alerts.js'
+import { notifySessionExpired, getRecentAlerts, dispatchNotificationDigest, setWebhookSecret } from './alerts.js'
+import { isDigestDue } from './notification-scheduler.js'
 
 export { observeForecast, estimateForecast } from './forecast.js'
 export { formatRelativeReset } from './relative-time.js'
@@ -91,7 +92,10 @@ export function apply(ctx, rawConfig) {
     return plainConfig(Config(plainConfig(rawConfig || {})))
   }
   let cachedConfig = resolveEntry()
-  const live = () => cachedConfig
+  const live = () => {
+    setWebhookSecret(cachedConfig.webhookSecret)
+    return cachedConfig
+  }
 
   function syncCustomVendors() {
     const profiles = validateProfiles(live().customVendors)
@@ -604,6 +608,22 @@ export function apply(ctx, rawConfig) {
     }
   }, 'dsh-subscriptions: vault-sync-loop')
 
+  // #720: interval digest for busy webhook channels.
+  ctx.effect(() => {
+    let lastDigestAt = 0
+    const tick = () => {
+      const cfg = live()
+      const alerts = getRecentAlerts(100)
+      if (!isDigestDue({ lastDigestAt, nowMs: Date.now(), intervalHours: cfg.digestIntervalHours, alertCount: alerts.length })) return
+      dispatchNotificationDigest(alerts, cfg.webhookUrl, fetch, { secret: cfg.webhookSecret })
+        .then((ok) => { if (ok) lastDigestAt = Date.now() })
+        .catch(() => {})
+    }
+    tick()
+    const id = setInterval(tick, 60 * 60 * 1000)
+    return () => clearInterval(id)
+  }, 'dsh-subscriptions: notification digest')
+
   registerRoutes(ctx, {
     NS,
     live,

package/lib/key-rotation-bridge.js

@@ -41,19 +41,50 @@ export function summarizeKeyRotationStatus(raw) {
   return { available: true, providers, totalKeys, healthyKeys }
 }
 
-export async function readKeyRotationStatus({ baseUrl, path = KEY_ROTATION_STATUS_PATH, fetchImpl = fetch, timeoutMs = 2000 } = {}) {
+// #726: a short TTL keeps the widget, settings panel and doctor from
+// multiplying key-rotation status reads. Errors are cached for the same TTL.
+let statusCache = { key: '', at: 0, value: null }
+let inFlight = null
+
+export function clearKeyRotationCache() {
+  statusCache = { key: '', at: 0, value: null }
+  inFlight = null
+}
+
+export async function readKeyRotationStatus({ baseUrl, path = KEY_ROTATION_STATUS_PATH, fetchImpl = fetch, timeoutMs = 2000, cacheTtlMs = 10000, bypassCache = false } = {}) {
   if (!baseUrl) return { available: false, reason: 'missing base url', providers: [], totalKeys: 0, healthyKeys: 0 }
+  const url = String(baseUrl).replace(/\/$/, '') + path
+  if (!bypassCache && statusCache.key === url && (Date.now() - statusCache.at) < Number(cacheTtlMs)) {
+    return statusCache.value
+  }
+  if (!bypassCache && inFlight && inFlight.key === url) return inFlight.promise
+  const promise = (async () => {
   try {
     const init = { method: 'GET', headers: { accept: 'application/json' } }
     if (timeoutMs > 0 && typeof AbortSignal !== 'undefined' && typeof AbortSignal.timeout === 'function') {
       init.signal = AbortSignal.timeout(timeoutMs)
     }
-    const res = await fetchImpl(String(baseUrl).replace(/\/$/, '') + path, init)
-    if (!res || !res.ok) return { available: false, reason: 'HTTP ' + (res && res.status), providers: [], totalKeys: 0, healthyKeys: 0 }
+    const res = await fetchImpl(url, init)
+    if (!res || !res.ok) {
+      const value = { available: false, reason: 'HTTP ' + (res && res.status), providers: [], totalKeys: 0, healthyKeys: 0 }
+      statusCache = { key: url, at: Date.now(), value }
+      return value
+    }
     const raw = await res.json()
-    return summarizeKeyRotationStatus(raw)
+    const value = summarizeKeyRotationStatus(raw)
+    statusCache = { key: url, at: Date.now(), value }
+    return value
   } catch (err) {
-    return { available: false, reason: String(err && err.message || err), providers: [], totalKeys: 0, healthyKeys: 0 }
+    const value = { available: false, reason: String(err && err.message || err), providers: [], totalKeys: 0, healthyKeys: 0 }
+    statusCache = { key: url, at: Date.now(), value }
+    return value
+  }
+  })()
+  inFlight = { key: url, promise }
+  try {
+    return await promise
+  } finally {
+    if (inFlight && inFlight.promise === promise) inFlight = null
   }
 }
 

package/lib/notification-scheduler.js

@@ -0,0 +1,7 @@
+// #720: digest scheduling is a pure decision so it can be tested without timers.
+export function isDigestDue({ lastDigestAt = 0, nowMs = Date.now(), intervalHours = 0, alertCount = 0 } = {}) {
+  if (!(Number(intervalHours) > 0)) return false
+  if (!(Number(alertCount) > 0)) return false
+  if (!lastDigestAt) return true
+  return Number(nowMs) - Number(lastDigestAt) >= Number(intervalHours) * 60 * 60 * 1000
+}

package/lib/routes/packs.js

@@ -0,0 +1,41 @@
+import { isTrustedSettingsRequest, readBody, safeJsonHandler, writeJson } from '../http.js'
+import { normalizeVendorPack } from '../vendor-pack.js'
+
+export function registerPacksRoutes(ctx) {
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-subscriptions/provider-packs/validate',
+    handler: safeJsonHandler(async (req, res) => {
+      if (req.method !== 'POST') {
+        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'POST only' } })
+        return
+      }
+      if (!isTrustedSettingsRequest(req, ctx)) {
+        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'same-origin only' } })
+        return
+      }
+      let body
+      try { body = JSON.parse((await readBody(req, 64 * 1024)).toString('utf8') || '{}') } catch {
+        writeJson(res, 400, { ok: false, error: { code: 'json', message: 'invalid json' } })
+        return
+      }
+      const raw = body && body.pack && typeof body.pack === 'object' ? body.pack : body
+      try {
+        const pack = normalizeVendorPack(raw)
+        writeJson(res, 200, {
+          ok: true,
+          pack: {
+            id: pack.id,
+            displayName: pack.displayName,
+            baseUrl: pack.baseUrl,
+            models: pack.models,
+            scope: pack.scope,
+            tokenStyle: pack.tokenStyle,
+          },
+        })
+      } catch (err) {
+        writeJson(res, 400, { ok: false, error: { code: 'pack', message: String(err && err.message || err) } })
+      }
+    }),
+  }), 'dsh-subscriptions: /provider-packs/validate')
+}

package/lib/routes.js

@@ -6,6 +6,7 @@ import { registerOauthRoutes } from './routes/oauth.js'
 import { registerAccountsRoutes } from './routes/accounts.js'
 import { registerProxyRoutes } from './routes/proxy.js'
 import { registerSourcesRoutes } from './routes/sources.js'
+import { registerPacksRoutes } from './routes/packs.js'
 import { registerPluginUpdater } from './updater.js'
 
 export function registerRoutes(ctx, state) {
@@ -111,4 +112,5 @@ function esc(x){return String(x==null?'':x).replace(/&/g,'&amp;').replace(/</g,'
   registerAccountsRoutes(ctx, state)
   registerProxyRoutes(ctx, state)
   registerSourcesRoutes(ctx, state)
+  registerPacksRoutes(ctx)
 }

package/package.json

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