mixdog 0.7.18 → 0.8.1

package/src/gateway/oauth-usage.mjs

@@ -1,598 +0,0 @@
-import {
-  closeSync,
-  existsSync,
-  openSync,
-  readFileSync,
-  readdirSync,
-  readSync,
-  statSync,
-} from 'fs';
-import { homedir } from 'os';
-import { join } from 'path';
-import { updateJsonAtomicSync } from '../shared/atomic-file.mjs';
-import { resolvePluginData } from '../shared/plugin-paths.mjs';
-import { getLlmDispatcher } from '../shared/llm/http-agent.mjs';
-
-const CACHE_FILE = 'gateway-oauth-usage-cache.json';
-const LIVE_CACHE_TTL_MS = 60_000;
-const DISK_CACHE_TTL_MS = 10 * 60_000;
-const NEGATIVE_CACHE_TTL_MS = 5 * 60_000;
-const FETCH_TIMEOUT_MS = 4500;
-const WARN_TTL_MS = 5 * 60_000;
-const MAX_ROLLOUT_FILES = 8;
-const MAX_ROLLOUT_SCAN_FILES = 2500;
-const MAX_TAIL_BYTES = 2 * 1024 * 1024;
-
-const memoryCache = new Map();
-const inflight = new Map();
-const lastWarnAt = new Map();
-
-function num(value, fallback = null) {
-  if (value === null || value === undefined || value === '') return fallback;
-  const n = Number(value);
-  return Number.isFinite(n) ? n : fallback;
-}
-
-function round(value, digits = 4) {
-  const n = Number(value);
-  if (!Number.isFinite(n)) return null;
-  const scale = 10 ** digits;
-  return Math.round(n * scale) / scale;
-}
-
-function cleanString(value) {
-  const s = typeof value === 'string' ? value.trim() : '';
-  return s || null;
-}
-
-function providerKey(routeInfo = {}) {
-  return String(routeInfo?.provider || '').toLowerCase();
-}
-
-function routeKey(routeInfo = {}) {
-  return `${providerKey(routeInfo)}\u0001${String(routeInfo?.model || '')}`;
-}
-
-function cachePath() {
-  return join(resolvePluginData(), CACHE_FILE);
-}
-
-function readJsonFile(file) {
-  try {
-    if (!existsSync(file)) return null;
-    return JSON.parse(readFileSync(file, 'utf8'));
-  } catch {
-    return null;
-  }
-}
-
-function writeSnapshotCache(key, snapshot) {
-  if (!key || !snapshot) return;
-  try {
-    updateJsonAtomicSync(cachePath(), (curRaw) => {
-      const cur = curRaw && typeof curRaw === 'object' ? curRaw : {};
-      const routes = cur.routes && typeof cur.routes === 'object' ? cur.routes : {};
-      return {
-        version: 1,
-        updatedAt: Date.now(),
-        routes: {
-          ...routes,
-          [key]: snapshot,
-        },
-      };
-    }, { compact: true, fsyncDir: true });
-  } catch {
-    // Usage display must never affect the gateway request path.
-  }
-}
-
-function isContentfulSnapshot(snapshot) {
-  return !!snapshot
-    && typeof snapshot === 'object'
-    && (
-      Array.isArray(snapshot.quotaWindows) && snapshot.quotaWindows.length > 0
-      || snapshot.balance && typeof snapshot.balance === 'object'
-    );
-}
-
-function hasFutureWindow(snapshot) {
-  const windows = Array.isArray(snapshot?.quotaWindows) ? snapshot.quotaWindows : [];
-  if (!windows.length) return true;
-  const now = Date.now();
-  return windows.some(w => !w?.resetAt || num(w.resetAt, 0) > now);
-}
-
-function freshSnapshot(snapshot, ttlMs) {
-  if (!isContentfulSnapshot(snapshot)) return null;
-  const at = num(snapshot.cachedAt, 0);
-  if (!at || Date.now() - at > ttlMs) return null;
-  if (!hasFutureWindow(snapshot)) return null;
-  return snapshot;
-}
-
-export function readCachedOAuthUsageSnapshot(routeInfo) {
-  const key = routeKey(routeInfo);
-  const providerOnlyKey = providerKey(routeInfo);
-  const mem = freshSnapshot(memoryCache.get(key), LIVE_CACHE_TTL_MS)
-    || freshSnapshot(memoryCache.get(providerOnlyKey), LIVE_CACHE_TTL_MS);
-  if (mem) return mem;
-
-  const raw = readJsonFile(cachePath());
-  const routes = raw?.routes && typeof raw.routes === 'object' ? raw.routes : {};
-  return freshSnapshot(routes[key], DISK_CACHE_TTL_MS)
-    || freshSnapshot(routes[providerOnlyKey], DISK_CACHE_TTL_MS)
-    || null;
-}
-
-function cacheNegative(key, source = 'none') {
-  if (!key) return;
-  memoryCache.set(key, { empty: true, source, cachedAt: Date.now() });
-}
-
-function negativeFresh(key) {
-  const cur = memoryCache.get(key);
-  return !!cur?.empty && Date.now() - num(cur.cachedAt, 0) < NEGATIVE_CACHE_TTL_MS;
-}
-
-function warnThrottled(log, key, message) {
-  const now = Date.now();
-  const last = num(lastWarnAt.get(key), 0);
-  if (last && now - last < WARN_TTL_MS) return;
-  lastWarnAt.set(key, now);
-  try { log(message); } catch {}
-}
-
-function fetchOptions(headers, timeoutMs = FETCH_TIMEOUT_MS) {
-  let dispatcher = null;
-  try { dispatcher = getLlmDispatcher(); } catch {}
-  return {
-    method: 'GET',
-    headers,
-    signal: AbortSignal.timeout(timeoutMs),
-    redirect: 'error',
-    ...(dispatcher ? { dispatcher } : {}),
-  };
-}
-
-function resetAtMs(value, fallbackSeconds = null) {
-  if (typeof value === 'string') {
-    const iso = Date.parse(value);
-    if (Number.isFinite(iso)) return iso;
-  }
-  const n = num(value, 0);
-  if (n > 0) return n < 10_000_000_000 ? n * 1000 : n;
-  const secs = num(fallbackSeconds, 0);
-  return secs > 0 ? Date.now() + secs * 1000 : null;
-}
-
-function labelForDuration(seconds, fallback) {
-  const s = num(seconds, 0);
-  if (s > 0) {
-    if (Math.abs(s - 5 * 60 * 60) <= 120) return '5H';
-    if (Math.abs(s - 7 * 24 * 60 * 60) <= 3600) return '7D';
-    if (Math.abs(s - 24 * 60 * 60) <= 600) return '24H';
-    if (s >= 28 * 24 * 60 * 60 && s <= 31 * 24 * 60 * 60) return 'M';
-  }
-  return fallback;
-}
-
-function windowFromPercent(label, value, source) {
-  const entry = value && typeof value === 'object' ? value : {};
-  const windowSeconds = num(entry.limit_window_seconds ?? entry.window_seconds ?? entry.windowSeconds, 0);
-  const windowMinutes = num(entry.window_minutes ?? entry.windowMinutes, 0);
-  const usedPct = num(
-    entry.usedPct
-      ?? entry.used_percent
-      ?? entry.used_percentage
-      ?? entry.utilization
-      ?? entry.percent,
-    null,
-  );
-  const limitUsd = num(entry.limitUsd ?? entry.limit_usd ?? entry.limit_dollars ?? entry.monthly_limit, null);
-  const usedUsd = num(entry.usedUsd ?? entry.used_usd ?? entry.used_dollars ?? entry.used_credits, null);
-  const remainingUsd = num(entry.remainingUsd ?? entry.remaining_usd ?? entry.remaining_dollars, null);
-  const resetAt = resetAtMs(
-    entry.resetAt ?? entry.resetsAt ?? entry.reset_at ?? entry.resets_at,
-    entry.reset_after_seconds,
-  );
-  const out = {
-    label: labelForDuration(windowSeconds || windowMinutes * 60, label),
-    source,
-  };
-  if (usedPct !== null) out.usedPct = round(usedPct, 2);
-  if (limitUsd !== null) out.limitUsd = round(limitUsd, 4);
-  if (usedUsd !== null) out.usedUsd = round(usedUsd, 4);
-  if (remainingUsd !== null) out.remainingUsd = round(remainingUsd, 4);
-  if (resetAt) out.resetAt = resetAt;
-  return Object.keys(out).length > 2 ? out : null;
-}
-
-function creditWindowFromBilling(config) {
-  if (!config || typeof config !== 'object') return null;
-  const limit = num(config.monthlyLimit?.val ?? config.monthlyLimit ?? config.includedLimit?.val, null);
-  const used = num(config.used?.val ?? config.includedUsed?.val ?? config.used, null);
-  if (limit === null || used === null || !(limit > 0)) return null;
-  const resetAt = resetAtMs(config.billingPeriodEnd ?? config.billing_period_end);
-  return {
-    label: 'M',
-    source: 'grok-build-billing',
-    usedPct: round(Math.min(100, used * 100 / limit), 2),
-    usedCredits: round(used, 2),
-    limitCredits: round(limit, 2),
-    remainingCredits: round(Math.max(0, limit - used), 2),
-    ...(resetAt ? { resetAt } : {}),
-  };
-}
-
-function balanceFromGrokBilling(config) {
-  if (!config || typeof config !== 'object') return null;
-  const cap = num(config.onDemandCap?.val ?? config.onDemandCap, null);
-  const used = num(config.onDemandUsed?.val ?? config.onDemandUsed, 0);
-  if (cap === null || !(cap > 0)) return null;
-  return {
-    source: 'grok-build-on-demand',
-    period: 'monthly',
-    budgetCredits: round(cap, 2),
-    spentCredits: round(used, 2),
-    remainingCredits: round(Math.max(0, cap - used), 2),
-  };
-}
-
-function balanceFromCredits(credits, source) {
-  if (!credits || typeof credits !== 'object') return null;
-  const balance = num(credits.balance ?? credits.remaining ?? credits.remaining_dollars, null);
-  if (balance === null) return null;
-  if (credits.has_credits === false && balance <= 0) return null;
-  return {
-    source,
-    remainingUsd: round(balance, 4),
-    currency: cleanString(credits.currency) || 'USD',
-  };
-}
-
-function balanceFromExtraUsage(extra) {
-  if (!extra || typeof extra !== 'object' || extra.is_enabled !== true) return null;
-  const limit = num(extra.monthly_limit, null);
-  const used = num(extra.used_credits, 0);
-  if (limit === null) return null;
-  return {
-    source: 'anthropic-oauth-extra',
-    period: 'monthly',
-    budgetUsd: round(limit, 4),
-    spentUsd: round(used, 4),
-    remainingUsd: round(Math.max(0, limit - used), 4),
-    currency: cleanString(extra.currency) || 'USD',
-  };
-}
-
-function normalizeOpenAIWhamUsage(data) {
-  const rate = data?.rate_limit && typeof data.rate_limit === 'object' ? data.rate_limit : null;
-  if (!rate) return null;
-  const windows = [
-    windowFromPercent('5H', rate.primary_window || rate.primary, 'openai-codex-oauth'),
-    windowFromPercent('7D', rate.secondary_window || rate.secondary, 'openai-codex-oauth'),
-  ].filter(Boolean);
-  if (!windows.length) return null;
-  return {
-    provider: 'openai-oauth',
-    source: 'openai-codex-wham',
-    planType: cleanString(data.plan_type),
-    quotaWindows: windows,
-    balance: balanceFromCredits(data.credits, 'openai-codex-credits'),
-    rawKeys: Object.keys(data || {}).sort(),
-  };
-}
-
-function normalizeCodexRateLimits(rateLimits, source = 'openai-codex-local') {
-  if (!rateLimits || typeof rateLimits !== 'object') return null;
-  const windows = [
-    windowFromPercent('5H', rateLimits.primary || rateLimits.five_hour, source),
-    windowFromPercent('7D', rateLimits.secondary || rateLimits.seven_day, source),
-  ].filter(Boolean);
-  if (!windows.length) return null;
-  return {
-    provider: 'openai-oauth',
-    source,
-    planType: cleanString(rateLimits.plan_type),
-    quotaWindows: windows,
-    balance: balanceFromCredits(rateLimits.credits, `${source}-credits`),
-  };
-}
-
-function normalizeAnthropicUsage(data, source = 'anthropic-oauth') {
-  if (!data || typeof data !== 'object') return null;
-  let windows = [
-    windowFromPercent('5H', data.five_hour, source),
-    windowFromPercent('7D', data.seven_day, source),
-  ].filter(Boolean);
-
-  if (!windows.length && Array.isArray(data.limits)) {
-    windows = data.limits
-      .filter(x => x && x.is_active !== false)
-      .map((x) => {
-        const label = x.kind === 'session' || x.group === 'session'
-          ? '5H'
-          : x.kind === 'weekly_all' || x.group === 'weekly'
-            ? '7D'
-            : String(x.kind || x.group || 'USE').toUpperCase();
-        return windowFromPercent(label, {
-          percent: x.percent,
-          resets_at: x.resets_at,
-        }, source);
-      })
-      .filter(Boolean);
-  }
-
-  const extra = data.extra_usage && data.extra_usage.is_enabled === true
-    ? windowFromPercent('EXTRA', {
-      utilization: data.extra_usage.utilization,
-      limit_dollars: data.extra_usage.monthly_limit,
-      used_dollars: data.extra_usage.used_credits,
-      remaining_dollars: Math.max(0, num(data.extra_usage.monthly_limit, 0) - num(data.extra_usage.used_credits, 0)),
-    }, 'anthropic-oauth-extra')
-    : null;
-  if (extra) windows.push(extra);
-
-  if (!windows.length && !data.extra_usage) return null;
-  return {
-    provider: 'anthropic-oauth',
-    source,
-    quotaWindows: windows,
-    balance: balanceFromExtraUsage(data.extra_usage),
-    rawKeys: Object.keys(data || {}).sort(),
-  };
-}
-
-function parseStatuslineRateLimits(raw, source) {
-  if (!raw || typeof raw !== 'object') return null;
-  const rateLimits = raw.rate_limits || raw.rateLimits;
-  if (!rateLimits || typeof rateLimits !== 'object') return null;
-  const windows = [
-    windowFromPercent('5H', rateLimits.five_hour || rateLimits.primary, source),
-    windowFromPercent('7D', rateLimits.seven_day || rateLimits.secondary, source),
-  ].filter(Boolean);
-  if (!windows.length) return null;
-  return { quotaWindows: windows, source };
-}
-
-function tailFileText(file, maxBytes = MAX_TAIL_BYTES) {
-  let fd = null;
-  try {
-    const st = statSync(file);
-    const size = st.size || 0;
-    const start = Math.max(0, size - maxBytes);
-    const len = size - start;
-    const buf = Buffer.alloc(len);
-    fd = openSync(file, 'r');
-    readSync(fd, buf, 0, len, start);
-    return buf.toString('utf8');
-  } catch {
-    return '';
-  } finally {
-    if (fd != null) {
-      try { closeSync(fd); } catch {}
-    }
-  }
-}
-
-function newestRolloutFiles(root) {
-  const out = [];
-  const stack = [root];
-  let seen = 0;
-  while (stack.length && seen < MAX_ROLLOUT_SCAN_FILES) {
-    const dir = stack.pop();
-    let entries = [];
-    try { entries = readdirSync(dir, { withFileTypes: true }); } catch { continue; }
-    for (const ent of entries) {
-      if (seen++ >= MAX_ROLLOUT_SCAN_FILES) break;
-      const full = join(dir, ent.name);
-      if (ent.isDirectory()) {
-        stack.push(full);
-      } else if (ent.isFile() && /^rollout-.*\.jsonl$/i.test(ent.name)) {
-        try {
-          const st = statSync(full);
-          out.push({ file: full, mtimeMs: st.mtimeMs || 0 });
-        } catch {}
-      }
-    }
-  }
-  return out
-    .sort((a, b) => b.mtimeMs - a.mtimeMs)
-    .slice(0, MAX_ROLLOUT_FILES)
-    .map(x => x.file);
-}
-
-function latestCodexRateLimitsFromRollout() {
-  const root = join(homedir(), '.codex', 'sessions');
-  if (!existsSync(root)) return null;
-  for (const file of newestRolloutFiles(root)) {
-    const lines = tailFileText(file).split(/\r?\n/).filter(Boolean);
-    for (let i = lines.length - 1; i >= 0; i--) {
-      try {
-        const row = JSON.parse(lines[i]);
-        const rateLimits = row?.payload?.rate_limits || row?.rate_limits;
-        const snap = normalizeCodexRateLimits(rateLimits, 'openai-codex-rollout');
-        if (snap && hasFutureWindow(snap)) return snap;
-      } catch {}
-    }
-  }
-  return null;
-}
-
-function latestClaudeStatuslineUsage() {
-  const file = join(homedir(), '.claude', 'cc-statusline-last.json');
-  const raw = readJsonFile(file);
-  const parsed = parseStatuslineRateLimits(raw, 'anthropic-oauth-statusline');
-  if (!parsed || !hasFutureWindow(parsed)) return null;
-  return {
-    provider: 'anthropic-oauth',
-    source: parsed.source,
-    quotaWindows: parsed.quotaWindows,
-  };
-}
-
-function grokCliIdentity(accessToken = '') {
-  const raw = readJsonFile(join(homedir(), '.grok', 'auth.json'));
-  if (!raw || typeof raw !== 'object') return {};
-  const entries = Object.values(raw).filter(v => v && typeof v === 'object');
-  const exact = accessToken ? entries.find(v => v.key === accessToken || v.access_token === accessToken) : null;
-  const entry = exact || entries.find(v => v.key || v.access_token) || null;
-  if (!entry) return {};
-  return {
-    userId: entry.user_id || entry.userId || entry.principal_id || entry.principalId || '',
-    token: entry.key || entry.access_token || entry.accessToken || '',
-  };
-}
-
-async function fetchOpenAICodexUsage(providerObj) {
-  const auth = await providerObj?.ensureAuth?.({ reason: 'usage' });
-  const token = auth?.access_token || auth?.accessToken;
-  if (!token) return latestCodexRateLimitsFromRollout();
-  const res = await fetch('https://chatgpt.com/backend-api/wham/usage', fetchOptions({
-    Authorization: `Bearer ${token}`,
-    originator: 'codex_cli_rs',
-    'chatgpt-account-id': auth.account_id || auth.accountId || '',
-    'OpenAI-Beta': 'responses=experimental',
-    Accept: 'application/json',
-  }));
-  if (!res.ok) throw new Error(`codex usage ${res.status}`);
-  const data = await res.json();
-  return normalizeOpenAIWhamUsage(data) || latestCodexRateLimitsFromRollout();
-}
-
-async function fetchAnthropicUsage(providerObj) {
-  const auth = await providerObj?.ensureAuth?.({ reason: 'usage' });
-  const token = auth?.accessToken || auth?.access_token;
-  if (!token) return latestClaudeStatuslineUsage();
-  const res = await fetch('https://api.anthropic.com/api/oauth/usage', fetchOptions({
-    Authorization: `Bearer ${token}`,
-    'anthropic-beta': 'oauth-2025-04-20',
-    'User-Agent': 'claude-code/2.0.0',
-    'Content-Type': 'application/json',
-    Accept: 'application/json',
-  }));
-  if (!res.ok) throw new Error(`anthropic oauth usage ${res.status}`);
-  const data = await res.json();
-  return normalizeAnthropicUsage(data) || latestClaudeStatuslineUsage();
-}
-
-async function fetchGrokUsage(providerObj, routeInfo) {
-  const auth = await providerObj?.ensureAuth?.({ reason: 'usage' });
-  const token = auth?.access_token || auth?.accessToken || auth?.key;
-  if (!token) return null;
-  const cliIdentity = grokCliIdentity(token);
-  const userId = auth?.user_id || auth?.userId || auth?.principal_id || auth?.principalId || cliIdentity.userId || '';
-  const cliHeaders = {
-    Authorization: `Bearer ${token}`,
-    'X-XAI-Token-Auth': 'xai-grok-cli',
-    'x-userid': userId,
-    Accept: 'application/json',
-    'User-Agent': 'xai-grok-build/0.2.16',
-  };
-
-  try {
-    const res = await fetch('https://cli-chat-proxy.grok.com/v1/billing', fetchOptions(cliHeaders));
-    if (res.ok) {
-      const data = await res.json();
-      const config = data?.config && typeof data.config === 'object' ? data.config : data;
-      const monthly = creditWindowFromBilling(config);
-      if (monthly) {
-        return {
-          provider: routeInfo?.provider || 'grok-oauth',
-          model: routeInfo?.model || null,
-          source: 'grok-build-billing',
-          quotaWindows: [monthly],
-          balance: balanceFromGrokBilling(config),
-          rawKeys: Object.keys(data || {}).sort(),
-        };
-      }
-    }
-  } catch {
-    // Fall through to generic probes below.
-  }
-
-  // xAI documents per-request cost tracking and console rate-limit pages, but
-  // the stable Grok Build quota is currently on the CLI proxy /billing route.
-  // Probe conservative generic candidates too so a future API addition starts
-  // working without changing the statusline contract.
-  const headers = {
-    Authorization: `Bearer ${token}`,
-    'X-XAI-Token-Auth': 'xai-grok-cli',
-    'x-userid': userId,
-    Accept: 'application/json',
-    'User-Agent': 'xai-grok-build/mixdog',
-  };
-  const urls = [
-    'https://cli-chat-proxy.grok.com/v1/billing',
-    'https://api.x.ai/v1/usage',
-    'https://api.x.ai/v1/rate_limits',
-    'https://api.x.ai/v1/rate-limits',
-    'https://cli-chat-proxy.grok.com/v1/usage',
-    'https://cli-chat-proxy.grok.com/v1/rate_limits',
-  ];
-  for (const url of urls) {
-    try {
-      const res = await fetch(url, fetchOptions(headers, 2500));
-      if (!res.ok) continue;
-      const data = await res.json();
-      const parsed = normalizeCodexRateLimits(data?.rate_limits || data?.rateLimits, 'grok-oauth')
-        || normalizeAnthropicUsage(data, 'grok-oauth')
-        || null;
-      if (parsed) return { ...parsed, provider: routeInfo?.provider || 'grok-oauth' };
-    } catch {}
-  }
-  return null;
-}
-
-export async function fetchOAuthUsageSnapshot(routeInfo, providerObj, log = () => {}) {
-  const provider = providerKey(routeInfo);
-  if (!provider.includes('oauth')) return null;
-  const key = routeKey(routeInfo);
-  const providerOnly = providerKey(routeInfo);
-  const cached = freshSnapshot(memoryCache.get(key), LIVE_CACHE_TTL_MS)
-    || freshSnapshot(memoryCache.get(providerOnly), LIVE_CACHE_TTL_MS);
-  if (cached) return cached;
-  if (negativeFresh(key) || negativeFresh(providerOnly)) return null;
-  if (inflight.has(key)) return inflight.get(key);
-
-  const task = (async () => {
-    let snapshot = null;
-    try {
-      if (provider === 'openai-oauth') {
-        snapshot = await fetchOpenAICodexUsage(providerObj);
-      } else if (provider === 'anthropic-oauth') {
-        snapshot = await fetchAnthropicUsage(providerObj);
-      } else if (provider === 'grok-oauth') {
-        snapshot = await fetchGrokUsage(providerObj, routeInfo);
-      }
-    } catch (err) {
-      if (provider === 'openai-oauth') snapshot = latestCodexRateLimitsFromRollout();
-      if (provider === 'anthropic-oauth') snapshot = latestClaudeStatuslineUsage();
-      if (!snapshot) {
-        warnThrottled(log, `oauth-usage:${provider}`, `gateway ${provider} usage fetch unavailable: ${err?.message || err}`);
-      }
-    }
-
-    if (!isContentfulSnapshot(snapshot)) {
-      cacheNegative(key, 'empty');
-      cacheNegative(providerOnly, 'empty');
-      return null;
-    }
-
-    const normalized = {
-      ...snapshot,
-      provider: routeInfo?.provider || snapshot.provider || provider,
-      model: routeInfo?.model || snapshot.model || null,
-      cachedAt: Date.now(),
-    };
-    memoryCache.set(key, normalized);
-    memoryCache.set(providerOnly, normalized);
-    writeSnapshotCache(key, normalized);
-    writeSnapshotCache(providerOnly, normalized);
-    return normalized;
-  })().finally(() => {
-    inflight.delete(key);
-  });
-  inflight.set(key, task);
-  return task;
-}