@goodandready/dsh-subscriptions 0.6.0 → 0.6.1

package/lib/routes/oauth.js

@@ -0,0 +1,248 @@
+import { normalizeSlots, vendorConfig } from '../accounts.js'
+import { escapeHtml, isTrustedSettingsRequest, queryOf, readBody, safeJsonHandler, writeHtml, writeJson } from '../http.js'
+import { startLoopback } from '../loopback.js'
+import { parseCallbackInput, requestOrigin } from '../oauth.js'
+import { createPkce } from '../pkce.js'
+import { displayName, isProvider, oauthRef } from '../refs.js'
+import { getVendor } from '../vendors/index.js'
+
+export function registerOauthRoutes(ctx, state) {
+  const {
+    live,
+    accountsView,
+    syncAdapter,
+    store,
+    redirectFor,
+    OK_HTML,
+    refreshModels,
+    pending,
+    completeOAuth,
+    fetchForRef,
+    sweepPending,
+    subscriptions,
+    pmL,
+  } = state
+
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-subscriptions/oauth/start',
+    handler: safeJsonHandler(async (req, res) => {
+      if (req.method !== 'GET') {
+        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'GET only' } })
+        return
+      }
+      const q = queryOf(req)
+      const provider = q.get('provider') || ''
+      const index = Number(q.get('index') || '1')
+      if (!isProvider(provider)) {
+        writeJson(res, 400, { ok: false, error: { code: 'provider', message: 'unknown provider' } })
+        return
+      }
+      const origin = requestOrigin(req)
+      const redirectUri = redirectFor(provider, live(), origin)
+      const pkce = await createPkce()
+      pending.set(pkce.state, {
+        provider,
+        index,
+        verifier: pkce.verifier,
+        challenge: pkce.challenge,
+        state: pkce.state,
+        redirectUri,
+        createdAt: Date.now(),
+      })
+      const cfg = { ...vendorConfig(provider, live()), redirectUri }
+      const url = getVendor(provider).authorizeUrl(cfg, pkce)
+      // #89: if redirect_uri is loopback - start a temporary catch server.
+      let autoCatch = false
+      if (live().autoLoopback) {
+        try {
+          const cb = new URL(redirectUri)
+          if (cb.hostname === 'localhost' || cb.hostname === '127.0.0.1') {
+            autoCatch = true
+            startLoopback({
+              redirectUri,
+              onCode: async (params) => {
+                const code = params.get('code') || ''
+                const state = params.get('state') || ''
+                if (!code) throw new Error('no code')
+                await completeOAuth({ provider, index, code, state })
+                return OK_HTML
+              },
+            }).catch(() => {})
+          }
+        } catch { autoCatch = false }
+      }
+      writeJson(res, 200, { ok: true, url, state: pkce.state, redirectUri, autoCatch })
+    }),
+  }), 'dsh-subscriptions: /oauth/start')
+
+
+  // #90: Device-code login (headless/VPS). Codex-only: auth.openai.com mints an
+  // authorization_code + code_verifier server-side; we finish with the normal
+  // PKCE exchange using the device redirect URI. Device code stays server-side
+  // in the pending map (same lifetime as PKCE pending rows).
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-subscriptions/oauth/device/start',
+    handler: safeJsonHandler(async (req, res) => {
+      if (req.method !== 'POST') {
+        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'POST only' } })
+        return
+      }
+      if (!isTrustedSettingsRequest(req)) {
+        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'same-origin only' } })
+        return
+      }
+      let body
+      try {
+        body = JSON.parse((await readBody(req, 16 * 1024)).toString('utf8'))
+      } catch {
+        writeJson(res, 400, { ok: false, error: { code: 'json', message: 'invalid json' } })
+        return
+      }
+      const provider = String(body.provider || '')
+      const index = Number(body.index || 1)
+      if (!isProvider(provider)) {
+        writeJson(res, 400, { ok: false, error: { code: 'provider', message: 'unknown provider' } })
+        return
+      }
+      const vendor = getVendor(provider)
+      if (typeof vendor.deviceStart !== 'function') {
+        writeJson(res, 400, { ok: false, error: { code: 'device', message: 'device login not supported for ' + provider } })
+        return
+      }
+      try {
+        const cfg = vendorConfig(provider, live())
+        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, {
+          kind: 'device',
+          provider,
+          index,
+          ref: oauthRef(provider, index),
+          deviceAuthId: start.deviceAuthId,
+          userCode: start.userCode,
+          intervalMs: start.intervalMs,
+          createdAt: Date.now(),
+        })
+        writeJson(res, 200, { ok: true, state, userCode: start.userCode, authUrl: start.authUrl, intervalMs: start.intervalMs })
+      } catch (e) {
+        writeJson(res, 502, { ok: false, error: { code: e && e.code || 'DEVICE', message: String(e && e.message || e).slice(0, 300) } })
+      }
+    }),
+  }), 'dsh-subscriptions: /oauth/device/start')
+
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-subscriptions/oauth/device/poll',
+    handler: safeJsonHandler(async (req, res) => {
+      if (req.method !== 'POST') {
+        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'POST only' } })
+        return
+      }
+      if (!isTrustedSettingsRequest(req)) {
+        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'same-origin only' } })
+        return
+      }
+      let body
+      try {
+        body = JSON.parse((await readBody(req, 16 * 1024)).toString('utf8'))
+      } catch {
+        writeJson(res, 400, { ok: false, error: { code: 'json', message: 'invalid json' } })
+        return
+      }
+      const state = String(body.state || '')
+      sweepPending(Date.now())
+      const row = pending.get(state)
+      if (!row || row.kind !== 'device') {
+        writeJson(res, 404, { ok: false, error: { code: 'expired', message: 'device login session expired; start again' } })
+        return
+      }
+      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) || fetch))
+        if (out.status !== 'authorized') {
+          writeJson(res, 200, { ok: true, status: out.status })
+          return
+        }
+        const slots = normalizeSlots(live().slots)
+        const slot = slots.find((s) => s.ref === row.ref)
+        const blob = out.blob
+        if (slot && slot.label) blob.label = slot.label
+        await store.saveBlob(row.ref, blob)
+        pending.delete(state)
+        await syncAdapter()
+        refreshModels().catch(() => {})
+        writeJson(res, 200, { ok: true, status: 'authorized', ref: row.ref, label: pmL(blob.label || blob.email) || displayName(row.provider) })
+      } catch (e) {
+        writeJson(res, 502, { ok: false, error: { code: e && e.code || 'DEVICE', message: String(e && e.message || e).slice(0, 300) } })
+      }
+    }),
+  }), 'dsh-subscriptions: /oauth/device/poll')
+
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-subscriptions/oauth/callback',
+    handler: async (req, res) => {
+      if (req.method !== 'GET') {
+        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'GET only' } })
+        return
+      }
+      const q = queryOf(req)
+      const code = q.get('code') || ''
+      const state = q.get('state') || ''
+      const row = pending.get(state)
+      if (!code || !row) {
+        writeHtml(res, 400, '<!doctype html><meta charset="utf-8"><title>Subscriptions</title><p>Login session missing. Return to Settings and paste the redirected URL.</p>')
+        return
+      }
+      try {
+        await completeOAuth({ provider: row.provider, index: row.index, code, state })
+        writeHtml(res, 200, '<!doctype html><meta charset="utf-8"><title>Subscriptions</title><p>Signed in. You can close this tab and return to Settings.</p>')
+      } catch (e) {
+        writeHtml(res, 400, `<!doctype html><meta charset="utf-8"><title>Subscriptions</title><p>${escapeHtml(String(e && e.message || e))}</p>`)
+      }
+    },
+  }), 'dsh-subscriptions: /oauth/callback')
+
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-subscriptions/oauth/complete',
+    handler: safeJsonHandler(async (req, res) => {
+      if (req.method !== 'POST') {
+        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'POST only' } })
+        return
+      }
+      if (!isTrustedSettingsRequest(req)) {
+        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'same-origin only' } })
+        return
+      }
+      let payload
+      try { payload = JSON.parse((await readBody(req, 16 * 1024)).toString('utf8') || '{}') } catch {
+        writeJson(res, 400, { ok: false, error: { code: 'json', message: 'invalid json' } })
+        return
+      }
+      const parsed = parseCallbackInput(payload.url || payload.code || '')
+      const provider = payload.provider
+      const index = payload.index
+      const code = parsed.code
+      const state = parsed.state || payload.state || ''
+      if (!code) {
+        writeJson(res, 400, { ok: false, error: { code: 'code', message: 'paste the redirected URL or the code' } })
+        return
+      }
+      try {
+        const result = await completeOAuth({ provider, index, code, state })
+        writeJson(res, 200, { ok: true, ...result, accounts: await accountsView() })
+      } catch (e) {
+        writeJson(res, 400, { ok: false, error: { code: 'oauth', message: String(e && e.message || e) } })
+      }
+    }),
+  }), 'dsh-subscriptions: /oauth/complete')
+}

package/lib/routes/proxy.js

@@ -0,0 +1,147 @@
+import { normalizeSlots, vendorConfig } from '../accounts.js'
+import { analyzeSessionEvents } from '../analyze-session.js'
+import { isTrustedSettingsRequest, readBody, safeJsonHandler, writeJson } from '../http.js'
+import { proxyFetch } from '../proxy.js'
+import { isProvider } from '../refs.js'
+
+export function registerProxyRoutes(ctx, state) {
+  const {
+    live,
+    subscriptions,
+  } = state
+
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-subscriptions/analyze-session',
+    handler: safeJsonHandler(async (req, res) => {
+      if (req.method !== 'POST') {
+        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'POST only' } })
+        return
+      }
+      const raw = await readBody(req, 128 * 1024).catch(() => Buffer.alloc(0))
+      let body = {}
+      try { body = JSON.parse(raw.toString('utf8') || '{}') } catch {}
+      const events = Array.isArray(body && body.events) ? body.events : []
+      const analysis = analyzeSessionEvents(events)
+      writeJson(res, 200, { ok: true, analysis })
+    }),
+  }), 'dsh-subscriptions: /analyze-session')
+
+
+
+
+  // HTTP proxy to the provider API through subscriptions.request.
+  // Same-origin only, path allowlist, rotation and quota as with models.
+  // The token never leaves the process - only the provider's response goes out.
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'prefix',
+    path: '/dsh-subscriptions/proxy',
+    handler: safeJsonHandler(async (req, res) => {
+      if (req.method !== 'POST' && req.method !== 'GET') {
+        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'GET or POST' } })
+        return
+      }
+      if (!isTrustedSettingsRequest(req)) {
+        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'same-origin only' } })
+        return
+      }
+      const url = new URL(req.url || '/', 'http://localhost')
+      const parts = url.pathname.replace(/^\/dsh-subscriptions\/proxy\//, '').split('/').filter(Boolean)
+      const provider = parts[0]
+      const restPath = '/' + parts.slice(1).join('/')
+      if (!isProvider(provider)) {
+        writeJson(res, 404, { ok: false, error: { code: 'provider', message: 'unknown provider' } })
+        return
+      }
+      let body
+      if (req.method === 'POST') {
+        try {
+          body = JSON.parse((await readBody(req, 1024 * 1024)).toString('utf8'))
+        } catch {
+          writeJson(res, 400, { ok: false, error: { code: 'json', message: 'invalid json' } })
+          return
+        }
+      }
+      try {
+        const out = await subscriptions.request({
+          provider,
+          path: restPath,
+          method: req.method === 'POST' ? 'POST' : 'GET',
+          body,
+          headers: {},
+        })
+        const text = await out.text()
+        try {
+          const json = JSON.parse(text)
+          writeJson(res, out.status || 200, json)
+        } catch {
+          res.writeHead(out.status || 200, { 'Content-Type': 'application/json' })
+          res.end(text)
+        }
+      } catch (e) {
+        const status = e && e.status ? e.status : (e && e.code === 'FORBIDDEN' ? 403 : (e && e.code === 'AUTH' ? 401 : 502))
+        writeJson(res, status, { ok: false, error: { code: e && e.code || 'VENDOR', message: String(e && e.message || e).slice(0, 300) } })
+      }
+    }),
+  }), 'dsh-subscriptions: proxy')
+
+
+  // #88: account proxy check - a real request to the provider endpoint with latency measurement.
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-subscriptions/proxy-check',
+    handler: safeJsonHandler(async (req, res) => {
+      if (req.method !== 'POST') {
+        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'POST only' } })
+        return
+      }
+      if (!isTrustedSettingsRequest(req)) {
+        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'same-origin only' } })
+        return
+      }
+      let body
+      try {
+        body = JSON.parse((await readBody(req, 16 * 1024)).toString('utf8'))
+      } catch {
+        writeJson(res, 400, { ok: false, error: { code: 'json', message: 'invalid json' } })
+        return
+      }
+      const provider = String(body.provider || '')
+      const index = Number(body.index || 1)
+      if (!isProvider(provider)) {
+        writeJson(res, 400, { ok: false, error: { code: 'provider', message: 'unknown provider' } })
+        return
+      }
+      const slots = normalizeSlots(live().slots)
+      const slot = slots.find((s) => s.provider === provider && s.index === index)
+      const proxyUrl = (slot && slot.proxyUrl) || ''
+      const DEFAULT_BASE = {
+        codex: 'https://chatgpt.com/backend-api/codex',
+        claude: 'https://api.anthropic.com',
+        grok: 'https://api.x.ai/v1',
+        antigravity: 'https://cloudcode-pa.googleapis.com',
+      }
+      const base = String((vendorConfig(provider, live()) || {}).baseUrl || DEFAULT_BASE[provider] || '').replace(/\/$/, '')
+      const started = Date.now()
+      try {
+        const impl = (proxyUrl && proxyFetch(proxyUrl)) || fetch
+        if (proxyUrl && impl === fetch) throw new Error('invalid proxy URL')
+        const out = await impl(base + '/models', {
+          method: 'GET',
+          headers: { Accept: 'application/json' },
+          signal: AbortSignal.timeout(10000),
+        })
+        // Any HTTP response (including 401/403) means the proxy and endpoint are reachable.
+        writeJson(res, 200, { ok: true, status: out.status, latencyMs: Date.now() - started, viaProxy: !!proxyUrl })
+      } catch (e) {
+        writeJson(res, 200, {
+          ok: false,
+          latencyMs: Date.now() - started,
+          viaProxy: !!proxyUrl,
+          error: { code: (e && e.code) || 'NETWORK', message: String((e && e.message) || e).slice(0, 200) },
+        })
+      }
+    }),
+  }), 'dsh-subscriptions: proxy-check')
+}

package/lib/routes/status.js

@@ -0,0 +1,257 @@
+import { normalizeSlots, vendorConfig } from '../accounts.js'
+import { Config, publicConfig } 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'
+import { getVendor } from '../vendors/index.js'
+
+export function registerStatusRoutes(ctx, state) {
+  const {
+    accountsView,
+    live,
+    getSettingsApi,
+    syncCustomVendors,
+    syncAdapter,
+    stripLegacySlots,
+    store,
+    history,
+    diagnosticsReport,
+    subscriptions,
+    pmL,
+    pmE,
+  } = state
+
+  async function configResponse() {
+    return {
+      ok: true,
+      config: publicConfig(live()),
+      accounts: await accountsView(),
+      providers: PROVIDERS.map((id) => ({ id, name: displayName(id) })),
+    }
+  }
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-subscriptions/config',
+    handler: async (req, res) => {
+      if (req.method === 'GET') {
+        writeJson(res, 200, await configResponse())
+        return
+      }
+      if (req.method !== 'PUT') {
+        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'GET or PUT' } })
+        return
+      }
+      if (!isTrustedSettingsRequest(req)) {
+        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'settings writes are same-origin only' } })
+        return
+      }
+      if (!getSettingsApi()) {
+        writeJson(res, 503, { ok: false, error: { code: 'settings', message: 'settings not ready' } })
+        return
+      }
+      let payload
+      try { payload = JSON.parse((await readBody(req, 256 * 1024)).toString('utf8') || '{}') } catch {
+        writeJson(res, 400, { ok: false, error: { code: 'json', message: 'invalid json' } })
+        return
+      }
+      if (payload && typeof payload.config === 'object') payload = payload.config
+      try {
+        if (Array.isArray(payload.slots)) payload.slots = stripLegacySlots(payload.slots)
+        const parsed = Config(payload)
+        const dropped = droppedCredentialRefs(live().slots, parsed.slots)
+        await getSettingsApi().replace(parsed)
+        syncCustomVendors()
+        for (const ref of dropped) await store.clearRef(ref)
+        await syncAdapter()
+        writeJson(res, 200, await configResponse())
+      } catch (e) {
+        writeJson(res, 400, { ok: false, error: { code: 'save', message: String(e && e.message || e) } })
+      }
+    },
+
+  
+
+  }), 'dsh-subscriptions: /config')
+
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-subscriptions/status',
+    handler: safeJsonHandler(async (req, res) => {
+      if (req.method !== 'GET') {
+        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'GET only' } })
+        return
+      }
+      const logged = await store.loggedInProviders()
+      // #66/#67: usagePercent (max across accounts) and expiresAt for the chip.
+      const usage = {}
+      const expires = {}
+      const labels = {}
+      for (const slot of normalizeSlots(live().slots)) {
+        try {
+          const info = await store.describeRef(slot.ref)
+          if (info.usagePercent != null) {
+            usage[slot.provider] = Math.max(usage[slot.provider] || 0, info.usagePercent)
+          }
+          // #67: subscription expiry date comes from the slot (entered in settings).
+          if (slot.expiresAt) {
+            expires[slot.provider] = Math.max(expires[slot.provider] || 0, slot.expiresAt)
+            labels[slot.provider] = pmL(slot.label || info.label || slot.provider)
+          }
+        } catch {}
+      }
+      // #69/#72: active subscription = last successful request (newest first).
+      let active = null
+      const last = history.recent(1)
+      if (last.length) {
+        const lastRow = last[0]
+        const accts = await store.listAccounts(lastRow.provider)
+        const acct = accts.find((a) => a.ref === lastRow.ref) || accts[0]
+        let plan = ''
+        let index = acct && acct.ref ? Number(String(acct.ref).split('_').pop()) || null : null
+        let status = 'ok'
+        let windows = []
+        try {
+          const info = await store.describeRef(lastRow.ref)
+          plan = info.paidTierName || ''
+          if (info.validationUrl) status = 'verify'
+          else if (info.cooldownUntil && info.cooldownUntil > Date.now()) status = 'cooldown'
+          if (Array.isArray(info.usage)) {
+            windows = info.usage
+              .filter((w) => w && typeof w.usedPercent === 'number')
+              .map((w) => ({ id: w.id || w.en || w.ru, label: w.en || w.ru || w.id, usedPercent: w.usedPercent }))
+          }
+        } catch {}
+        active = {
+          provider: lastRow.provider,
+          index,
+          model: lastRow.model || null,
+          path: lastRow.path || null,
+          plan,
+          windows,
+          usagePercent: usage[lastRow.provider] != null ? usage[lastRow.provider] : null,
+          status,
+          at: lastRow.ts,
+        }
+      }
+      writeJson(res, 200, {
+        ok: true,
+        loggedIn: Object.fromEntries(PROVIDERS.map((id) => [id, logged.includes(id)])),
+        usagePercent: usage,
+        expiresAt: expires,
+        labels,
+        expiryNotifyDays: live().expiryNotifyDays,
+        fastMode: !!live().codexFastMode,
+        composerQuota: String(live().composerQuota || 'off'),
+        active,
+      })
+    }),
+  }), 'dsh-subscriptions: /status')
+
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-subscriptions/diagnostics',
+    handler: safeJsonHandler(async (req, res) => {
+      if (req.method !== 'GET') {
+        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'GET only' } })
+        return
+      }
+      writeJson(res, 200, { ok: true, report: await diagnosticsReport() })
+    }),
+  }), 'dsh-subscriptions: /diagnostics')
+
+
+  // ponytail: cheap per-vendor probe; never sets cooldown, never returns tokens
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-subscriptions/check',
+    handler: safeJsonHandler(async (req, res) => {
+      if (req.method !== 'POST') {
+        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'POST only' } })
+        return
+      }
+      if (!isTrustedSettingsRequest(req)) {
+        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'same-origin only' } })
+        return
+      }
+      let payload
+      try { payload = JSON.parse((await readBody(req, 8 * 1024)).toString('utf8') || '{}') } catch {
+        writeJson(res, 400, { ok: false, error: { code: 'json', message: 'invalid json' } })
+        return
+      }
+      const provider = payload.provider
+      if (!isProvider(provider)) {
+        writeJson(res, 200, { ok: false, provider, error: { code: 'provider', message: 'unknown provider' } })
+        return
+      }
+      const ref = oauthRef(provider, payload.index)
+      const info = await store.describeRef(ref)
+      if (!info.configured) {
+        writeJson(res, 200, { ok: false, provider, index: payload.index, ref, error: { code: 'not_connected', message: 'not connected' } })
+        return
+      }
+      let blob
+      try { blob = await store.loadBlob(ref) } catch (e) {
+        writeJson(res, 200, { ok: false, provider, index: payload.index, ref, error: { code: 'auth', message: String(e && e.message || e) } })
+        return
+      }
+      try { blob = await store.ensureFresh(provider, blob, ref) } catch (e) {
+        writeJson(res, 200, {
+          ok: false, provider, index: payload.index, ref,
+          email: pmE(blob.email), label: pmL(blob.label), expiresAt: blob.expiresAt || null,
+          quota: info.quota || null,
+          error: { code: 'refresh', message: String(e && e.message || e) },
+        })
+        return
+      }
+      const vendor = getVendor(provider)
+      if (typeof vendor.check !== 'function') {
+        writeJson(res, 200, { ok: true, provider, index: payload.index, ref, email: pmE(blob.email), label: pmL(blob.label), expiresAt: blob.expiresAt || null, quota: info.quota || null })
+        return
+      }
+      let capturedQuota = null
+      const probeFetch = async (url, init) => {
+        const res2 = await fetch(url, init)
+        try {
+          const snap = quotaSnapshot(provider, res2.headers, null, Date.now())
+          if (snap) { capturedQuota = snap; store.rememberQuota(ref, snap) }
+        } catch {}
+        return res2
+      }
+      try {
+        await vendor.check(blob, vendorConfig(provider, live()), probeFetch)
+        writeJson(res, 200, { ok: true, provider, index: payload.index, ref, email: pmE(blob.email), label: pmL(blob.label), expiresAt: blob.expiresAt || null, quota: capturedQuota || info.quota || null, usagePercent: info.usagePercent ?? null })
+      } catch (e) {
+        writeJson(res, 200, {
+          ok: false, provider, index: payload.index, ref,
+          email: pmE(blob.email), label: pmL(blob.label), expiresAt: blob.expiresAt || null,
+          quota: capturedQuota || info.quota || null,
+          error: { code: e && e.code ? e.code : 'VENDOR', message: String(e && e.message || e).slice(0, 300) },
+        })
+      }
+    }),
+  }), 'dsh-subscriptions: /check')
+
+
+  // #50: summary page /subscriptions (localhost-only).
+  // #65: request and cost history (JSON).
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-subscriptions/history',
+    handler: async (req, res) => {
+      if (req.method !== 'GET') {
+        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'GET only' } })
+        return
+      }
+      const host = (req.headers.host || '').split(':')[0]
+      if (host !== 'localhost' && host !== '127.0.0.1') {
+        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'localhost only' } })
+        return
+      }
+      const limit = Math.min(Number(queryOf(req).get('limit') || '10'), 100)
+      writeJson(res, 200, { ok: true, total: history.size(), items: history.recent(limit) })
+    },
+  }), 'dsh-subscriptions: /history')
+}