@goodandready/dsh-subscriptions 0.6.91 → 0.7.3

package/bin/dsh-subscriptions.mjs

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+import process from 'node:process'
+import { pathToFileURL } from 'node:url'
+
+export function parseArgs(argv) {
+  const args = Array.isArray(argv) ? argv.slice() : []
+  const command = args.shift() || 'status'
+  const options = { command, csv: false, type: 'accounts', sessionId: '', mode: 'fast', help: false }
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i]
+    if (arg === '--csv') options.csv = true
+    else if (arg === '--help' || arg === '-h') options.help = true
+    else if (arg === '--type') options.type = args[++i] || 'accounts'
+    else if (arg === '--session') options.sessionId = args[++i] || ''
+    else if (command === 'fast' && !options.sessionId) options.sessionId = arg
+    else if (command === 'fast') options.mode = arg === 'standard' || arg === 'off' ? 'standard' : 'fast'
+  }
+  return options
+}
+
+export function buildRequest(options, env = process.env) {
+  const base = String(env.DSH_SUBS_URL || 'http://127.0.0.1:3080/dsh-subscriptions').replace(/\/$/, '')
+  const headers = { Accept: 'application/json' }
+  if (env.DSH_AUTH_TOKEN) headers.Authorization = 'Bearer ' + env.DSH_AUTH_TOKEN
+  if (options.command === 'status') return { url: base + '/status', init: { method: 'GET', headers } }
+  if (options.command === 'usage') {
+    const params = new URLSearchParams({ type: options.type || 'accounts', format: options.csv ? 'csv' : 'json' })
+    return { url: base + '/usage?' + params.toString(), init: { method: 'GET', headers } }
+  }
+  if (options.command === 'fast') {
+    if (!options.sessionId) throw new Error('fast requires a session id: dsh-subscriptions fast <session> [fast|standard]')
+    headers['Content-Type'] = 'application/json'
+    return {
+      url: base + '/speed',
+      init: { method: 'POST', headers, body: JSON.stringify({ sessionId: options.sessionId, mode: options.mode || 'fast' }) },
+    }
+  }
+  throw new Error('unknown command: ' + options.command)
+}
+
+export async function run(argv = process.argv.slice(2), env = process.env, fetchImpl = fetch) {
+  const options = parseArgs(argv)
+  if (options.help) return { help: true }
+  const request = buildRequest(options, env)
+  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))
+  return { text, contentType: res.headers.get('content-type') || '' }
+}
+
+async function main() {
+  const result = await run()
+  if (result.help) {
+    process.stdout.write('Usage: dsh-subscriptions <status|usage|fast> [options]\n  usage --csv --type accounts|calls\n  fast <session> [fast|standard]\n')
+    return
+  }
+  process.stdout.write(result.text.endsWith('\n') ? result.text : result.text + '\n')
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  main().catch((err) => {
+    process.stderr.write(String(err && err.message || err) + '\n')
+    process.exitCode = 1
+  })
+}

package/lib/adapter-manager.js

@@ -36,6 +36,7 @@ export function createAdapterManager({
   }
 
   const adapter = new SubscriptionAdapter({
+    live: () => live(),
     listAccounts: (provider) => store.listAccounts(provider),
     loadBlob: (ref) => store.loadBlob(ref),
     ensureFresh: (provider, blob, ref) => store.ensureFresh(provider, blob, ref),
@@ -46,6 +47,8 @@ export function createAdapterManager({
     drainSafetyPercent: () => live().drainSafetyPercent,
     switchAtRemaining: () => live().switchAtRemaining,
     rotationStrategy: () => live().rotationStrategy,
+    rateLimitWait: () => live().rateLimitWait,
+    rateLimitMaxWaitMs: () => live().rateLimitMaxWaitMs,
     enableSoftFailureSentinel: () => live().enableSoftFailureSentinel,
     rememberCooldown: (ref, until, families) => store.rememberCooldown(ref, until, families),
     rememberQuarantine: (ref, reason, until, attempts) => store.rememberQuarantine(ref, reason, until, attempts),

package/lib/adapter.js

@@ -3,6 +3,8 @@ import { inferModelCapabilities, isDeprecatedId } from './models-catalog.js'
 import { fetchWithTimeout } from "./http.js"
 import { LlmAdapter, LlmError, attributionHeaders } from '@deepseek-ai/dsh-llm'
 import { displayName } from './refs.js'
+import { applyModelSettings, bestAccountPlan } from './model-settings.js'
+import { getSpeedMode } from './speed-mode.js'
 import { getVendor } from './vendors/index.js'
 import { modelCatalog } from './messages.js'
 import { streamWithRotation } from './stream-rotate.js'
@@ -21,6 +23,9 @@ function asLlmError(err) {
   try {
     const out = new LlmError(message, code)
     if (err && err.validationUrl) out.validationUrl = err.validationUrl
+    if (err && err.retryAfterMs != null) out.retryAfterMs = err.retryAfterMs
+    if (err && err.resetAt != null) out.resetAt = err.resetAt
+    if (err && err.retryAfter != null) out.retryAfter = err.retryAfter
     return out
   } catch {
     return err
@@ -86,7 +91,7 @@ export class SubscriptionAdapter extends LlmAdapter {
         capabilities: Array.isArray(m.capabilities) && m.capabilities.length ? m.capabilities : caps.capabilities,
       }
     })
-    return models
+    return applyModelSettings(provider, models, this.deps.live ? this.deps.live() : {}, bestAccountPlan(accounts))
   }
 
   imageRequestPricing() {
@@ -112,7 +117,7 @@ export class SubscriptionAdapter extends LlmAdapter {
         ...(reasoningMeta ? { reasoning: reasoningMeta } : {}),
       }
     }
-    return { provider, id: model, name: model, ...(reasoningMeta ? { reasoning: reasoningMeta } : {}) }
+    return { provider, id: model, name: (found && found.name) || model, ...(reasoningMeta ? { reasoning: reasoningMeta } : {}), ...(found && found.contextWindow ? { context: { contextWindow: found.contextWindow } } : {}) }
   }
 
   async prepareCall(provider, model, signal) {
@@ -153,6 +158,7 @@ export class SubscriptionAdapter extends LlmAdapter {
       const decisionTrace = {}
       const streamOptions = {
         ...options,
+        ...(provider === 'codex' && getSpeedMode(sessionId) === 'fast' ? { service_tier: 'priority' } : {}),
         ...(effectiveReasoning.effort ? { reasoningEffort: effectiveReasoning.effort } : {}),
         ...(effectiveReasoning.budgetTokens ? { thinkingBudget: effectiveReasoning.budgetTokens } : {}),
         _decisionTrace: decisionTrace,
@@ -161,6 +167,8 @@ export class SubscriptionAdapter extends LlmAdapter {
         drainSafetyPercent: effectiveDrainSafetyPercent,
         rotationStrategy: effectiveRotationStrategy,
         enableSoftFailureSentinel: effectiveSoftFailureSentinel,
+        rateLimitWait: typeof deps.rateLimitWait === 'function' ? deps.rateLimitWait() : deps.rateLimitWait,
+        rateLimitMaxWaitMs: typeof deps.rateLimitMaxWaitMs === 'function' ? deps.rateLimitMaxWaitMs() : deps.rateLimitMaxWaitMs,
       }
       for await (const event of streamWithRotation({
         accounts: await deps.listAccounts(provider),

package/lib/alerts.js

@@ -1,4 +1,5 @@
 import { readFileSync } from 'node:fs'
+import { createHmac } from 'node:crypto'
 
 let pkgVersion = ''
 try {
@@ -59,35 +60,66 @@ export function getRecentAlerts(limit = 50) {
   return alertBuffer.slice(-Math.max(1, Math.min(limit, MAX_ALERTS))).reverse()
 }
 
-/**
- * Dispatches an alert asynchronously to an external webhookUrl if provided.
- */
-export async function dispatchWebhookAlert(alert, webhookUrl, fetchImpl = fetch) {
+// #696: signed, retrying webhook delivery plus a digest endpoint payload.
+export async function dispatchWebhookAlert(alert, webhookUrl, fetchImpl = fetch, options = {}) {
   if (!alert || !webhookUrl || typeof webhookUrl !== 'string' || !webhookUrl.startsWith('http')) {
     return false
   }
+  return dispatchNotification({ event: 'subscription_alert', alert }, webhookUrl, fetchImpl, options)
+}
 
-  const payload = {
-    event: 'subscription_alert',
-    alert,
-    source: 'dsh-subscriptions',
-    sentAt: new Date().toISOString(),
+export function buildNotificationDigest(alerts, { windowMs = 24 * 60 * 60 * 1000, nowMs = Date.now() } = {}) {
+  const since = nowMs - Math.max(0, Number(windowMs) || 0)
+  const recent = (Array.isArray(alerts) ? alerts : []).filter((a) => a && Number(a.timestamp) >= since)
+  const bySeverity = {}
+  const byType = {}
+  for (const a of recent) {
+    bySeverity[a.severity || 'warn'] = (bySeverity[a.severity || 'warn'] || 0) + 1
+    byType[a.type || 'unknown'] = (byType[a.type || 'unknown'] || 0) + 1
   }
+  return {
+    total: recent.length,
+    bySeverity,
+    byType,
+    since: new Date(since).toISOString(),
+    until: new Date(nowMs).toISOString(),
+  }
+}
 
-  try {
-    const res = await fetchImpl(webhookUrl, {
-      method: 'POST',
-      headers: {
-        'content-type': 'application/json',
-        'user-agent': pkgVersion ? `dsh-subscriptions/${pkgVersion}` : 'dsh-subscriptions',
-      },
-      body: JSON.stringify(payload),
-    })
-    return res.ok
-  } catch {
-    // Non-blocking fire-and-forget
-    return false
+export async function dispatchNotificationDigest(alerts, webhookUrl, fetchImpl = fetch, options = {}) {
+  if (!webhookUrl) return false
+  const digest = buildNotificationDigest(alerts, options)
+  return dispatchNotification({ event: 'subscription_digest', digest }, webhookUrl, fetchImpl, options)
+}
+
+async function dispatchNotification(body, webhookUrl, fetchImpl, options) {
+  const { secret = '', retries = 1, timeoutMs = 5000, sleep } = options || {}
+  const payload = { ...body, source: 'dsh-subscriptions', sentAt: new Date().toISOString() }
+  const raw = JSON.stringify(payload)
+  const headers = {
+    'content-type': 'application/json',
+    'user-agent': pkgVersion ? `dsh-subscriptions/${pkgVersion}` : 'dsh-subscriptions',
+  }
+  if (secret) headers['x-dsh-signature'] = 'sha256=' + createHmac('sha256', String(secret)).update(raw).digest('hex')
+  headers['x-dsh-timestamp'] = payload.sentAt
+  const wait = typeof sleep === 'function' ? sleep : (ms) => new Promise((resolve) => setTimeout(resolve, ms))
+  const attempts = Math.max(0, Number(retries) || 0) + 1
+  for (let attempt = 0; attempt < attempts; attempt += 1) {
+    try {
+      const init = { method: 'POST', headers, body: raw }
+      if (timeoutMs > 0 && typeof AbortSignal !== 'undefined' && typeof AbortSignal.timeout === 'function') {
+        init.signal = AbortSignal.timeout(timeoutMs)
+      }
+      const res = await fetchImpl(webhookUrl, init)
+      if (res && res.ok) return true
+      const status = Number(res && res.status) || 0
+      if (status && status < 500) return false
+    } catch {
+      // retry network errors
+    }
+    if (attempt + 1 < attempts) await wait(250 * (2 ** attempt))
   }
+  return false
 }
 
 /**