@goodandready/dsh-subscriptions 0.1.0

package/lib/usage.js

@@ -0,0 +1,51 @@
+export function numberOrNull(value) {
+  const n = Number(value)
+  return Number.isFinite(n) ? n : null
+}
+
+export function windowPercent(obj) {
+  if (!obj || typeof obj !== 'object') return null
+  return numberOrNull(
+    obj.utilization ?? obj.used_percent ?? obj.usedPercent ?? obj.creditUsagePercent ?? obj.used_percentage,
+  )
+}
+
+export function deepestUsedPercent(obj) {
+  let max = null
+  function walk(value, depth) {
+    if (!value || typeof value !== 'object' || depth > 8) return
+    const here = windowPercent(value)
+    if (here != null) max = max == null ? here : Math.max(max, here)
+    const remaining = numberOrNull(value.remainingFraction)
+    if (remaining != null) {
+      const used = (1 - remaining) * 100
+      max = max == null ? used : Math.max(max, used)
+    }
+    const usedFrac = numberOrNull(value.usedFraction)
+    if (usedFrac != null) {
+      const used = usedFrac * 100
+      max = max == null ? used : Math.max(max, used)
+    }
+    for (const child of Object.values(value)) {
+      if (child && typeof child === 'object') walk(child, depth + 1)
+    }
+  }
+  walk(obj, 0)
+  return max
+}
+
+export function grokBillingPercent(json) {
+  const cfg = json && json.config && typeof json.config === 'object' ? json.config : json
+  const ready = numberOrNull(cfg && cfg.creditUsagePercent)
+  if (ready != null) return ready
+  const limit = numberOrNull(cfg && (cfg.monthlyLimit ?? cfg.limit))
+  const used = numberOrNull(cfg && (cfg.used ?? cfg.usedCredits))
+  if (limit && limit > 0 && used != null) return (used / limit) * 100
+  return deepestUsedPercent(json)
+}
+
+export function asUsageSnapshot(percent) {
+  const usedPercent = numberOrNull(percent)
+  if (usedPercent == null) return null
+  return { usedPercent }
+}

package/lib/vendors/antigravity-oauth.js

@@ -0,0 +1,10 @@
+export function builtinAntigravityOAuth() {
+  // Public Antigravity IDE OAuth app (same credentials as desktop IDE).
+  const clientId = String.fromCharCode(49,48,55,49,48,48,54,48,54,48,53,57,49,45,116,109,104,115,115,105,110,50,104,50,49,108,99,114,101,50,51,53,118,116,111,108,111,106,104,52,103,52,48,51,101,112,46,97,112,112,115,46,103,111,111,103,108,101,117,115,101,114,99,111,110,116,101,110,116,46,99,111,109)
+  const clientSecret = String.fromCharCode(71,79,67,83,80,88,45,75,53,56,70,87,82,52,56,54,76,100,76,74,49,109,76,66,56,115,88,67,52,122,54,113,68,65,102)
+  return {
+    clientId,
+    clientSecret,
+    redirectUri: 'https://antigravity.google/oauth-callback',
+  }
+}

package/lib/vendors/antigravity.js

@@ -0,0 +1,152 @@
+import { randomUUID } from 'node:crypto'
+import { buildAuthorizeUrl } from '../oauth.js'
+import { googleContents } from '../messages.js'
+import { formTokenRequest, googleStream, throwHttpError, tokenBlobFromOAuth } from '../wire.js'
+import { emailFromToken } from '../jwt.js'
+import { builtinAntigravityOAuth } from './antigravity-oauth.js'
+import {
+  CODE_ASSIST_STREAM,
+  antigravityMetadata,
+  antigravityIdentityHeaders,
+  discoverProject,
+  fetchAvailableModels,
+  retrieveQuotaPercent,
+  streamEnvelope,
+  assistHeaders,
+} from '../code-assist.js'
+
+export const id = 'antigravity'
+
+const AUTH = 'https://accounts.google.com/o/oauth2/v2/auth'
+const TOKEN = 'https://oauth2.googleapis.com/token'
+const SCOPE = [
+  'https://www.googleapis.com/auth/cloud-platform',
+  'https://www.googleapis.com/auth/userinfo.email',
+  'https://www.googleapis.com/auth/userinfo.profile',
+  'https://www.googleapis.com/auth/cclog',
+  'https://www.googleapis.com/auth/experimentsandconfigs',
+].join(' ')
+
+export function providerInfo() {
+  return { id, name: 'Antigravity' }
+}
+
+export function defaults() {
+  const builtin = builtinAntigravityOAuth()
+  return {
+    clientId: builtin.clientId,
+    clientSecret: builtin.clientSecret,
+    redirectUri: builtin.redirectUri,
+    models: ['gemini-3.5-flash-low', 'gemini-3-flash', 'gemini-2.5-flash'],
+  }
+}
+
+export function authorizeUrl(cfg, pkce) {
+  return buildAuthorizeUrl({
+    authUrl: AUTH,
+    clientId: cfg.clientId,
+    redirectUri: cfg.redirectUri,
+    challenge: pkce.challenge,
+    state: pkce.state,
+    scope: SCOPE,
+    extra: { access_type: 'offline', prompt: 'consent' },
+  })
+}
+
+function headersFor(projectId) {
+  return antigravityIdentityHeaders(projectId)
+}
+
+function metadataFor(projectId) {
+  return antigravityMetadata(projectId)
+}
+
+async function withProject(blob, fetchImpl, saveBlob) {
+  if (blob.projectId && blob.paidTierId) {
+    return { ...blob, sessionId: blob.sessionId || randomUUID() }
+  }
+  try {
+    const meta = metadataFor(blob.projectId || '')
+    const found = await discoverProject(fetchImpl, blob.accessToken, meta, headersFor(blob.projectId || ''))
+    const next = {
+      ...blob,
+      projectId: found.projectId || blob.projectId || '',
+      paidTierId: found.paidTierId || blob.paidTierId || '',
+      paidTierName: found.paidTierName || blob.paidTierName || '',
+      sessionId: blob.sessionId || randomUUID(),
+    }
+    if (saveBlob) await saveBlob(next)
+    return next
+  } catch (e) {
+    if (e && e.code === 'VALIDATION_REQUIRED' && e.validationUrl) {
+      return { ...blob, validationUrl: e.validationUrl, validationMessage: String(e.message || '') }
+    }
+    return blob
+  }
+}
+
+export async function exchangeCode(cfg, pkce, code, fetchImpl) {
+  const json = await formTokenRequest(TOKEN, {
+    client_id: cfg.clientId,
+    client_secret: cfg.clientSecret || '',
+    grant_type: 'authorization_code',
+    code,
+    redirect_uri: cfg.redirectUri,
+    code_verifier: pkce.verifier,
+  }, fetchImpl)
+  const blob = tokenBlobFromOAuth(json)
+  const labeled = { ...blob, email: blob.email || emailFromToken(blob.accessToken), label: blob.label || 'Antigravity' }
+  return withProject(labeled, fetchImpl)
+}
+
+export async function refresh(cfg, blob, fetchImpl) {
+  const json = await formTokenRequest(TOKEN, {
+    client_id: cfg.clientId,
+    client_secret: cfg.clientSecret || '',
+    grant_type: 'refresh_token',
+    refresh_token: blob.refreshToken,
+  }, fetchImpl)
+  return tokenBlobFromOAuth(json, {
+    label: blob.label,
+    email: blob.email,
+    projectId: blob.projectId,
+    paidTierId: blob.paidTierId,
+    paidTierName: blob.paidTierName,
+    sessionId: blob.sessionId,
+  })
+}
+
+export async function listModels(blob, cfg, fetchImpl) {
+  const fallback = cfg.models || defaults().models
+  return fetchAvailableModels(fetchImpl || fetch, blob.accessToken, headersFor(blob.projectId || ''), fallback, id)
+}
+
+export async function usage(blob, _cfg, fetchImpl) {
+  return retrieveQuotaPercent(fetchImpl || fetch, blob.accessToken, headersFor(blob.projectId || ''))
+}
+
+export async function* streamOnce({ blob, options, fetchImpl, headers, config, signal, saveBlob }) {
+  const ready = await withProject(blob, fetchImpl, saveBlob)
+  const { envelope, sessionId } = streamEnvelope({
+    projectId: ready.projectId,
+    model: options.model,
+    request: googleContents(options),
+    userAgent: 'antigravity',
+    sessionId: ready.sessionId,
+    paidTierId: ready.paidTierId,
+  })
+  const res = await fetchImpl(`${CODE_ASSIST_STREAM}:streamGenerateContent?alt=sse`, {
+    method: 'POST',
+    headers: {
+      ...headers,
+      ...assistHeaders(ready.accessToken, { ...headersFor(ready.projectId || ''), Accept: 'text/event-stream' }),
+    },
+    body: JSON.stringify(envelope),
+    signal,
+  })
+  if (!res.ok) throwHttpError(res.status, await res.text())
+  if (saveBlob && sessionId && sessionId !== ready.sessionId) {
+    await saveBlob({ ...ready, sessionId })
+  }
+  yield* googleStream(res.body)
+}

package/lib/vendors/claude.js

@@ -0,0 +1,119 @@
+import { buildAuthorizeUrl } from '../oauth.js'
+import { anthropicPayload, modelCatalog } from '../messages.js'
+import { jsonTokenRequest, anthropicStream, httpError, tokenBlobFromOAuth, readJson } from '../wire.js'
+import { emailFromToken } from '../jwt.js'
+import { asUsageSnapshot, deepestUsedPercent } from '../usage.js'
+
+export const id = 'claude'
+
+const AUTH = 'https://claude.ai/oauth/authorize'
+const TOKEN = 'https://platform.claude.com/v1/oauth/token'
+const API = 'https://api.anthropic.com/v1/messages?beta=true'
+const PROFILE = 'https://api.anthropic.com/api/oauth/profile'
+const USAGE = 'https://api.anthropic.com/api/oauth/usage'
+const SCOPE = 'org:create_api_key user:profile user:inference user:sessions:claude_code user:mcp_servers user:file_upload'
+const IDENTITY = "You are Claude Code, Anthropic's official CLI for Claude."
+const BETA = 'oauth-2025-04-20,claude-code-20250219'
+
+export function providerInfo() {
+  return { id, name: 'Claude' }
+}
+
+export function defaults() {
+  return {
+    clientId: '9d1c250a-e61b-44d9-88ed-5944d1962f5e',
+    redirectUri: 'https://console.anthropic.com/oauth/code/callback',
+    models: [
+      { id: 'claude-opus-5', name: 'Claude Opus 5' },
+      { id: 'claude-sonnet-5', name: 'Claude Sonnet 5' },
+      { id: 'claude-fable-5', name: 'Claude Fable 5' },
+      { id: 'claude-haiku-4-5-20251001', name: 'Claude Haiku 4.5' },
+    ],
+    systemPrefix: IDENTITY,
+  }
+}
+
+function oauthHeaders(token) {
+  return {
+    Authorization: `Bearer ${token}`,
+    Accept: 'application/json',
+    'anthropic-version': '2023-06-01',
+    'anthropic-beta': BETA,
+  }
+}
+
+export function authorizeUrl(cfg, pkce) {
+  return buildAuthorizeUrl({
+    authUrl: AUTH,
+    clientId: cfg.clientId,
+    redirectUri: cfg.redirectUri,
+    challenge: pkce.challenge,
+    state: pkce.state,
+    scope: SCOPE,
+    extra: { code: 'true' },
+  })
+}
+
+async function decorate(blob, fetchImpl) {
+  let email = blob.email || emailFromToken(blob.accessToken)
+  if (!email && fetchImpl && blob.accessToken) {
+    try {
+      const res = await fetchImpl(PROFILE, { headers: oauthHeaders(blob.accessToken) })
+      const json = await readJson(res)
+      email = json.email || (json.account && json.account.email) || email
+    } catch { /* profile is optional */ }
+  }
+  return { ...blob, email, label: blob.label || email || 'Claude' }
+}
+
+export async function exchangeCode(cfg, pkce, code, fetchImpl) {
+  const json = await jsonTokenRequest(TOKEN, {
+    grant_type: 'authorization_code',
+    client_id: cfg.clientId,
+    code,
+    redirect_uri: cfg.redirectUri,
+    code_verifier: pkce.verifier,
+    state: pkce.state,
+  }, fetchImpl)
+  return decorate(tokenBlobFromOAuth(json), fetchImpl)
+}
+
+export async function refresh(cfg, blob, fetchImpl) {
+  const json = await jsonTokenRequest(TOKEN, {
+    grant_type: 'refresh_token',
+    client_id: cfg.clientId,
+    refresh_token: blob.refreshToken,
+  }, fetchImpl)
+  return decorate(tokenBlobFromOAuth(json, { label: blob.label, email: blob.email }), fetchImpl)
+}
+
+export async function listModels(blob, cfg) {
+  return modelCatalog(id, cfg.models || defaults().models)
+}
+
+export async function usage(blob, _cfg, fetchImpl) {
+  try {
+    const res = await (fetchImpl || fetch)(USAGE, { headers: oauthHeaders(blob.accessToken) })
+    const json = await readJson(res)
+    return asUsageSnapshot(deepestUsedPercent(json))
+  } catch {
+    return null
+  }
+}
+
+export async function* streamOnce({ blob, options, fetchImpl, headers, config, signal }) {
+  const payload = anthropicPayload(options, config.systemPrefix || IDENTITY)
+  const res = await fetchImpl(API, {
+    method: 'POST',
+    headers: {
+      ...headers,
+      ...oauthHeaders(blob.accessToken),
+      'Content-Type': 'application/json',
+      Accept: 'text/event-stream',
+    },
+    body: JSON.stringify(payload),
+    signal,
+  })
+  if (!res.ok) throw httpError(res.status, await res.text())
+  yield* anthropicStream(res.body)
+}

package/lib/vendors/codex.js

@@ -0,0 +1,163 @@
+import { randomUUID } from 'node:crypto'
+import { buildAuthorizeUrl } from '../oauth.js'
+import { codexResponsesBody, modelCatalog } from '../messages.js'
+import { chatgptAccountId, emailFromToken } from '../jwt.js'
+import { formTokenRequest, codexResponsesStream, readJson, tokenBlobFromOAuth, httpError } from '../wire.js'
+import { asUsageSnapshot, deepestUsedPercent } from '../usage.js'
+
+export const id = 'codex'
+
+const AUTH = 'https://auth.openai.com/oauth/authorize'
+const TOKEN = 'https://auth.openai.com/oauth/token'
+const USAGE = 'https://chatgpt.com/backend-api/wham/usage'
+const SCOPE = 'openid profile email offline_access api.connectors.read api.connectors.invoke'
+const INSTRUCTIONS = 'You are a coding assistant using a ChatGPT Codex subscription.'
+
+export function providerInfo() {
+  return { id, name: 'ChatGPT Codex' }
+}
+
+export function defaults() {
+  return {
+    clientId: 'app_EMoamEEZ73f0CkXaXp7hrann',
+    redirectUri: 'http://localhost:1455/auth/callback',
+    baseUrl: 'https://chatgpt.com/backend-api/codex',
+    originator: 'codex_cli_rs',
+    models: [
+      { id: 'gpt-5.1-codex', name: 'GPT-5.1 Codex' },
+      { id: 'gpt-5.1-codex-mini', name: 'GPT-5.1 Codex Mini' },
+      { id: 'gpt-5.1', name: 'GPT-5.1' },
+    ],
+    clientVersion: '0.147.0',
+  }
+}
+
+export function authorizeUrl(cfg, pkce) {
+  return buildAuthorizeUrl({
+    authUrl: AUTH,
+    clientId: cfg.clientId,
+    redirectUri: cfg.redirectUri,
+    challenge: pkce.challenge,
+    state: pkce.state,
+    scope: SCOPE,
+    extra: {
+      id_token_add_organizations: 'true',
+      codex_cli_simplified_flow: 'true',
+      originator: cfg.originator || 'codex_cli_rs',
+    },
+  })
+}
+
+function identityHeaders(blob, config, extra) {
+  const originator = config.originator || 'codex_cli_rs'
+  return {
+    Authorization: `Bearer ${blob.accessToken}`,
+    originator,
+    'chatgpt-account-id': blob.accountId || '',
+    'ChatGPT-Account-ID': blob.accountId || '',
+    'User-Agent': `${originator}/0.0.1`,
+    'OpenAI-Beta': 'responses=experimental',
+    ...(extra || {}),
+  }
+}
+
+function decorate(blob, json) {
+  const idToken = (json && json.id_token) || blob.idToken || ''
+  return {
+    ...blob,
+    accountId: blob.accountId || chatgptAccountId(idToken) || chatgptAccountId(blob.accessToken),
+    email: blob.email || emailFromToken(idToken) || emailFromToken(blob.accessToken),
+    label: blob.label || emailFromToken(idToken) || emailFromToken(blob.accessToken) || 'ChatGPT',
+  }
+}
+
+export async function exchangeCode(cfg, pkce, code, fetchImpl) {
+  const json = await formTokenRequest(TOKEN, {
+    grant_type: 'authorization_code',
+    client_id: cfg.clientId,
+    code,
+    redirect_uri: cfg.redirectUri,
+    code_verifier: pkce.verifier,
+  }, fetchImpl)
+  return decorate(tokenBlobFromOAuth(json), json)
+}
+
+export async function refresh(cfg, blob, fetchImpl) {
+  const json = await formTokenRequest(TOKEN, {
+    grant_type: 'refresh_token',
+    client_id: cfg.clientId,
+    refresh_token: blob.refreshToken,
+  }, fetchImpl)
+  return decorate(tokenBlobFromOAuth(json, {
+    label: blob.label,
+    email: blob.email,
+    accountId: blob.accountId,
+  }), json)
+}
+
+export async function listModels(blob, cfg, fetchImpl) {
+  const catalog = modelCatalog(id, cfg.models || defaults().models)
+  const impl = fetchImpl || fetch
+  try {
+    const base = (cfg.baseUrl || defaults().baseUrl).replace(/\/$/, '')
+    const version = cfg.clientVersion || defaults().clientVersion
+    const res = await impl(`${base}/models?client_version=${encodeURIComponent(version)}`, {
+      headers: identityHeaders(blob, cfg, { Accept: 'application/json' }),
+    })
+    const json = await readJson(res)
+    const rows = []
+    for (const entry of json.models || json.data || []) {
+      const slug = entry && (entry.slug || entry.id)
+      if (!slug) continue
+      if (entry.visibility === 'hide' || entry.visibility === 'none') continue
+      const efforts = (entry.supported_reasoning_levels || [])
+        .map((level) => (typeof level === 'string' ? level : level && level.effort))
+        .filter(Boolean)
+        .map((effort) => ({ id: effort, name: effort }))
+      rows.push({
+        id: slug,
+        name: entry.display_name || slug,
+        priority: Number(entry.priority) || 0,
+        ...(entry.description ? { description: entry.description } : {}),
+        ...(entry.context_window ? { contextWindow: entry.context_window } : {}),
+        ...(efforts.length ? { reasoning: { efforts } } : {}),
+      })
+    }
+    if (!rows.length) throw new Error('empty codex catalog')
+    rows.sort((a, b) => a.priority - b.priority)
+    return modelCatalog(id, rows.map(({ priority, ...row }) => row))
+  } catch { /* catalog fallback */ }
+  return catalog
+}
+
+export async function usage(blob, cfg, fetchImpl) {
+  try {
+    const res = await (fetchImpl || fetch)(USAGE, {
+      headers: identityHeaders(blob, cfg, { Accept: 'application/json' }),
+    })
+    const json = await readJson(res)
+    return asUsageSnapshot(deepestUsedPercent(json))
+  } catch {
+    return null
+  }
+}
+
+export async function* streamOnce({ blob, options, fetchImpl, headers, config, signal }) {
+  const base = (config.baseUrl || defaults().baseUrl).replace(/\/$/, '')
+  const body = codexResponsesBody(options, INSTRUCTIONS)
+  const res = await fetchImpl(`${base}/responses`, {
+    method: 'POST',
+    headers: {
+      ...headers,
+      ...identityHeaders(blob, config, {
+        'Content-Type': 'application/json',
+        Accept: 'text/event-stream',
+        'session-id': randomUUID(),
+      }),
+    },
+    body: JSON.stringify(body),
+    signal,
+  })
+  if (!res.ok) throw httpError(res.status, await res.text())
+  yield* codexResponsesStream(res.body)
+}