swayrouter 1.0.0

package/src/services/tokenRefresh.js

@@ -0,0 +1,274 @@
+import { PROVIDERS } from "../config/providers.js";
+import { OAUTH_ENDPOINTS, REFRESH_LEAD_MS } from "../config/appConstants.js";
+import {
+  refreshXaiToken,
+  refreshAccessToken,
+  refreshKimiToken,
+  refreshClaudeOAuthToken,
+  refreshGoogleToken,
+  refreshCodexToken,
+  refreshKiroToken,
+  refreshGitHubToken,
+  refreshCopilotToken,
+  refreshCodebuddyToken,
+  refreshCodebuddyIntlToken,
+  refreshTraeToken,
+  refreshWindsurfToken,
+  classifyOAuthRefreshError,
+} from "./tokenRefresh/providers.js";
+
+export {
+  refreshAccessToken,
+  refreshKimiToken,
+  refreshClaudeOAuthToken,
+  refreshGoogleToken,
+  refreshCodexToken,
+  refreshKiroToken,
+  refreshGitHubToken,
+  refreshCopilotToken,
+  refreshCodebuddyToken,
+  refreshCodebuddyIntlToken,
+  refreshTraeToken,
+  refreshWindsurfToken,
+  classifyOAuthRefreshError,
+};
+
+export const TOKEN_EXPIRY_BUFFER_MS = 5 * 60 * 1000;
+
+export function isUnrecoverableRefreshError(result) {
+  return (
+    result &&
+    typeof result === "object" &&
+    (result.error === "unrecoverable_refresh_error" ||
+      result.error === "refresh_token_reused" ||
+      result.error === "invalid_request" ||
+      result.error === "invalid_grant")
+  );
+}
+
+export function getRefreshLeadMs(provider) {
+  if (REFRESH_LEAD_MS[provider]) return REFRESH_LEAD_MS[provider];
+
+  if (provider === "kimi-coding" && REFRESH_LEAD_MS.kimi) return REFRESH_LEAD_MS.kimi;
+  return TOKEN_EXPIRY_BUFFER_MS;
+}
+
+export function parseVertexSaJson(apiKey) {
+  if (typeof apiKey !== "string") return null;
+  try {
+    const parsed = JSON.parse(apiKey);
+    if (parsed.type === "service_account" && parsed.client_email && parsed.private_key && parsed.project_id) {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+const vertexTokenCache = new Map();
+
+export async function refreshVertexToken(saJson, log) {
+  const cacheKey = saJson.client_email;
+  const cached = vertexTokenCache.get(cacheKey);
+
+  if (cached && cached.expiresAt - Date.now() > 5 * 60 * 1000) {
+    return { accessToken: cached.token, expiresAt: cached.expiresAt };
+  }
+
+  try {
+    const { SignJWT, importPKCS8 } = await import("jose");
+    log?.debug?.("TOKEN_REFRESH", `Vertex minting token for ${saJson.client_email}`);
+    const privateKey = await importPKCS8(saJson.private_key.replace(/\\n/g, "\n"), "RS256");
+    const now = Math.floor(Date.now() / 1000);
+
+    const jwt = await new SignJWT({ scope: "https://www.googleapis.com/auth/cloud-platform" })
+      .setProtectedHeader({ alg: "RS256" })
+      .setIssuer(saJson.client_email)
+      .setAudience(OAUTH_ENDPOINTS.google.token)
+      .setIssuedAt(now)
+      .setExpirationTime(now + 3600)
+      .sign(privateKey);
+
+    const res = await fetch(OAUTH_ENDPOINTS.google.token, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams({
+        grant_type: "urn:ietf:params:oauth:grant-type:jwt-bearer",
+        assertion: jwt,
+      }),
+    });
+
+    if (!res.ok) {
+      const err = await res.text();
+      log?.error?.("TOKEN_REFRESH", `Vertex token mint failed: ${err}`);
+      return null;
+    }
+
+    const { access_token, expires_in } = await res.json();
+    const expiresAt = Date.now() + (expires_in ?? 3600) * 1000;
+
+    vertexTokenCache.set(cacheKey, { token: access_token, expiresAt });
+    log?.info?.("TOKEN_REFRESH", `Vertex token minted for ${saJson.client_email}`);
+
+    return { accessToken: access_token, expiresAt };
+  } catch (error) {
+    log?.error?.("TOKEN_REFRESH", `Vertex token error: ${error.message}`);
+    return null;
+  }
+}
+
+function vertexRefreshHandler(c, log) {
+  const saJson = parseVertexSaJson(c.apiKey);
+  if (!saJson) return null;
+  return refreshVertexToken(saJson, log);
+}
+
+const REFRESH_HANDLERS = {
+  "gemini-cli": (c, log) => refreshGoogleToken(c.refreshToken, PROVIDERS["gemini-cli"].clientId, PROVIDERS["gemini-cli"].clientSecret, log),
+  antigravity: (c, log) => refreshGoogleToken(c.refreshToken, PROVIDERS.antigravity.clientId, PROVIDERS.antigravity.clientSecret, log),
+  claude: (c, log) => refreshClaudeOAuthToken(c.refreshToken, log),
+  codex: (c, log) => refreshCodexToken(c.refreshToken, log),
+  github: (c, log) => refreshGitHubToken(c.refreshToken, log),
+  kiro: (c, log) => refreshKiroToken(c.refreshToken, c.providerSpecificData, log),
+  xai: (c, log) => refreshXaiToken(c.refreshToken, log),
+
+  "grok-cli": (c, log) => refreshXaiToken(c.refreshToken, log),
+  gcli: (c, log) => refreshXaiToken(c.refreshToken, log),
+  "codebuddy-cn": (c, log) => refreshCodebuddyToken(c.refreshToken, log),
+  "codebuddy-intl": (c, log) => refreshCodebuddyIntlToken(c.refreshToken, log),
+  trae: (c, log) => refreshTraeToken(c.refreshToken, c, log),
+  windsurf: (c, log) => refreshWindsurfToken(c, log),
+
+  kimi: (c, log) => refreshKimiToken(c.refreshToken, c, log),
+  "kimi-coding": (c, log) => refreshKimiToken(c.refreshToken, c, log),
+  vertex: vertexRefreshHandler,
+  "vertex-partner": vertexRefreshHandler
+};
+
+export async function getAccessToken(provider, credentials, log) {
+  if (!credentials || !credentials.refreshToken || typeof credentials.refreshToken !== "string") {
+    log?.warn?.("TOKEN_REFRESH", `No valid refresh token available for provider: ${provider}`);
+    return null;
+  }
+  return _getAccessTokenInternal(provider, credentials, log);
+}
+
+async function _getAccessTokenInternal(provider, credentials, log) {
+  if (provider === "gemini") {
+    return refreshGoogleToken(credentials.refreshToken, PROVIDERS.gemini.clientId, PROVIDERS.gemini.clientSecret, log);
+  }
+  const handler = REFRESH_HANDLERS[provider];
+  if (!handler) {
+    log?.warn?.("TOKEN_REFRESH", `Unsupported provider for token refresh: ${provider}`);
+    return null;
+  }
+  return handler(credentials, log);
+}
+
+export async function refreshTokenByProvider(provider, credentials, log) {
+  if (!credentials.refreshToken) return null;
+  const handler = REFRESH_HANDLERS[provider];
+  return handler ? handler(credentials, log) : refreshAccessToken(provider, credentials.refreshToken, credentials, log);
+}
+
+export function formatProviderCredentials(provider, credentials, log) {
+  const config = PROVIDERS[provider];
+  if (!config) {
+    log?.warn?.("TOKEN_REFRESH", `No configuration found for provider: ${provider}`);
+    return null;
+  }
+
+  switch (provider) {
+    case "gemini":
+      return {
+        apiKey: credentials.apiKey,
+        accessToken: credentials.accessToken,
+        projectId: credentials.projectId
+      };
+
+    case "claude":
+      return {
+        apiKey: credentials.apiKey,
+        accessToken: credentials.accessToken
+      };
+
+    case "codex":
+    case "openai":
+    case "openrouter":
+    case "xai":
+    case "grok-cli":
+      return {
+        apiKey: credentials.apiKey,
+        accessToken: credentials.accessToken
+      };
+
+    case "antigravity":
+    case "gemini-cli":
+      return {
+        accessToken: credentials.accessToken,
+        refreshToken: credentials.refreshToken,
+        projectId: credentials.projectId
+      };
+
+    default:
+      return {
+        apiKey: credentials.apiKey,
+        accessToken: credentials.accessToken,
+        refreshToken: credentials.refreshToken
+      };
+  }
+}
+
+export async function getAllAccessTokens(userInfo, log) {
+  const results = {};
+
+  if (userInfo.connections && Array.isArray(userInfo.connections)) {
+    for (const connection of userInfo.connections) {
+      if (connection.isActive && connection.provider) {
+        const token = await getAccessToken(connection.provider, {
+          refreshToken: connection.refreshToken
+        }, log);
+
+        if (token) {
+          results[connection.provider] = token;
+        }
+      }
+    }
+  }
+
+  return results;
+}
+
+export async function refreshWithRetry(refreshFn, maxRetries = 3, log = null, signal = null) {
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    if (signal?.aborted) return null;
+    if (attempt > 0) {
+      const delay = attempt * 1000;
+      log?.debug?.("TOKEN_REFRESH", `Retry ${attempt}/${maxRetries} after ${delay}ms`);
+      await new Promise((resolve) => {
+        let timer = setTimeout(resolve, delay);
+        const onAbort = () => {
+          clearTimeout(timer);
+          signal?.removeEventListener("abort", onAbort);
+          resolve();
+        };
+        if (signal) {
+          if (signal.aborted) onAbort();
+          else signal.addEventListener("abort", onAbort, { once: true });
+        }
+      });
+      if (signal?.aborted) return null;
+    }
+
+    try {
+      const result = await refreshFn();
+      if (result) return result;
+    } catch (error) {
+      log?.warn?.("TOKEN_REFRESH", `Attempt ${attempt + 1}/${maxRetries} failed: ${error.message}`);
+    }
+  }
+
+  log?.error?.("TOKEN_REFRESH", `All ${maxRetries} retry attempts failed`);
+  return null;
+}

package/src/services/usage/claude.js

@@ -0,0 +1,134 @@
+import { proxyAwareFetch } from "../../utils/proxyFetch.js";
+import { ANTHROPIC_API_VERSION } from "../../providers/shared.js";
+import { U, parseResetTime } from "./shared.js";
+
+const CLAUDE_CONFIG = {
+  oauthUsageUrl: U("claude").oauthUrl,
+  usageUrl: U("claude").orgUrl,
+  settingsUrl: U("claude").settingsUrl,
+  apiVersion: ANTHROPIC_API_VERSION,
+};
+
+const OAUTH_429_COOLDOWN_MS = 180000;
+const oauthCooldown = new Map();
+
+export async function getClaudeUsage(accessToken, proxyOptions = null) {
+  try {
+
+    const cooldownUntil = oauthCooldown.get(accessToken);
+    if (cooldownUntil && Date.now() < cooldownUntil) {
+      return await getClaudeUsageLegacy(accessToken, proxyOptions);
+    }
+
+    const oauthResponse = await proxyAwareFetch(CLAUDE_CONFIG.oauthUsageUrl, {
+      method: "GET",
+      headers: {
+        "Authorization": `Bearer ${accessToken}`,
+        "anthropic-beta": "oauth-2025-04-20",
+        "anthropic-version": CLAUDE_CONFIG.apiVersion,
+      },
+    }, proxyOptions);
+
+    if (oauthResponse.ok) {
+      const data = await oauthResponse.json();
+      const quotas = {};
+
+      const hasUtilization = (window) =>
+        window && typeof window === "object" && typeof window.utilization === "number";
+
+      const createQuotaObject = (window) => {
+        const used = window.utilization;
+        const remaining = Math.max(0, 100 - used);
+        return {
+          used,
+          total: 100,
+          remaining,
+          remainingPercentage: remaining,
+          resetAt: parseResetTime(window.resets_at),
+          unlimited: false,
+        };
+      };
+
+      if (hasUtilization(data.five_hour)) {
+        quotas["session (5h)"] = createQuotaObject(data.five_hour);
+      }
+
+      if (hasUtilization(data.seven_day)) {
+        quotas["weekly (7d)"] = createQuotaObject(data.seven_day);
+      }
+
+      for (const [key, value] of Object.entries(data)) {
+        if (key.startsWith("seven_day_") && key !== "seven_day" && hasUtilization(value)) {
+          const modelName = key.replace("seven_day_", "");
+          quotas[`weekly ${modelName} (7d)`] = createQuotaObject(value);
+        }
+      }
+
+      return {
+        plan: "Claude Code",
+        extraUsage: data.extra_usage ?? null,
+        quotas,
+      };
+    }
+
+    if (oauthResponse.status === 429) {
+      oauthCooldown.set(accessToken, Date.now() + OAUTH_429_COOLDOWN_MS);
+    }
+
+    console.warn(`[Claude Usage] OAuth endpoint returned ${oauthResponse.status}, falling back to legacy`);
+    return await getClaudeUsageLegacy(accessToken, proxyOptions);
+  } catch (error) {
+    console.error("[Claude Usage] Failed to fetch usage:", error);
+    return { message: "Claude connected. Unable to fetch usage." };
+  }
+}
+
+async function getClaudeUsageLegacy(accessToken, proxyOptions = null) {
+  try {
+    const settingsResponse = await proxyAwareFetch(CLAUDE_CONFIG.settingsUrl, {
+      method: "GET",
+      headers: {
+        "Authorization": `Bearer ${accessToken}`,
+        "anthropic-version": CLAUDE_CONFIG.apiVersion,
+      },
+    }, proxyOptions);
+
+    if (settingsResponse.ok) {
+      const settings = await settingsResponse.json();
+
+      if (settings.organization_id) {
+        const usageResponse = await proxyAwareFetch(
+          CLAUDE_CONFIG.usageUrl.replace("{org_id}", settings.organization_id),
+          {
+            method: "GET",
+            headers: {
+              "Authorization": `Bearer ${accessToken}`,
+              "anthropic-version": CLAUDE_CONFIG.apiVersion,
+            },
+          },
+          proxyOptions
+        );
+
+        if (usageResponse.ok) {
+          const usage = await usageResponse.json();
+          return {
+            plan: settings.plan || "Unknown",
+            organization: settings.organization_name,
+            quotas: usage,
+          };
+        }
+      }
+
+      return {
+        plan: settings.plan || "Unknown",
+        organization: settings.organization_name,
+        message: "Claude connected. Usage details require admin access.",
+      };
+    }
+
+    return { message: "Claude connected. Usage API requires admin permissions." };
+  } catch (error) {
+    console.error("[Claude Usage] Legacy usage failed:", error);
+    return { message: "Claude connected. Unable to fetch usage." };
+  }
+}

package/src/services/usage/codebuddy-cn.js

@@ -0,0 +1,212 @@
+import { PROVIDERS } from "../../providers/index.js";
+import { U, fetchWithTimeout, parseResetTime } from "./shared.js";
+
+const PROVIDER_ID = "codebuddy-cn";
+
+function num(precise, plain) {
+  const n = Number(precise ?? plain);
+  return Number.isFinite(n) ? n : 0;
+}
+
+function firstValue(object, keys) {
+  for (const key of keys) {
+    const value = object?.[key];
+    if (value !== undefined && value !== null && value !== "") return value;
+  }
+  return undefined;
+}
+
+function numberValue(object, keys) {
+  return num(firstValue(object, keys), 0);
+}
+
+function extractAccounts(payload) {
+  const candidates = [
+    payload?.data?.Response?.Data?.Accounts,
+    payload?.data?.Response?.Data?.accounts,
+    payload?.data?.Response?.Accounts,
+    payload?.data?.Response?.accounts,
+    payload?.data?.Accounts,
+    payload?.data?.accounts,
+    payload?.Response?.Data?.Accounts,
+    payload?.Response?.Data?.accounts,
+    payload?.Accounts,
+    payload?.accounts,
+    Array.isArray(payload?.data) ? payload.data : null,
+    Array.isArray(payload) ? payload : null,
+  ];
+  return candidates.find(Array.isArray) || [];
+}
+
+function accountDescriptor(account) {
+  return [
+    account?.PackageName,
+    account?.SubProductName,
+    account?.ProductName,
+    account?.PackageDisplayName,
+    account?.ResourceName,
+    account?.Name,
+    account?.PackageCode,
+  ]
+    .filter((value) => value !== undefined && value !== null)
+    .join(" ")
+    .toLowerCase();
+}
+
+function accountLabel(account) {
+  const descriptor = accountDescriptor(account);
+  if (/free|免费|_035_/.test(descriptor)) return "Free Plan";
+  if (/bonus|gift|trial|赠送|_006_/.test(descriptor)) return "Bonus Pack";
+  return "Quota";
+}
+
+function timestamp(value) {
+  const parsed = parseResetTime(value);
+  return parsed ? new Date(parsed).getTime() : Number.NaN;
+}
+
+function refillCadence(acc) {
+  const start = parseResetTime(acc.CycleStartTime);
+  const end = parseResetTime(acc.CycleEndTime);
+  if (start && end) {
+    const days = (new Date(end).getTime() - new Date(start).getTime()) / 86400000;
+    if (days <= 1.5) return "Daily";
+    if (days <= 10) return "Weekly";
+  }
+  return "Monthly";
+}
+
+function buildCodeBuddyQuotas(accounts) {
+  const cycleEndMs = (account) => {
+    const value = timestamp(account.CycleEndTime);
+    return Number.isFinite(value) ? value : Number.POSITIVE_INFINITY;
+  };
+
+  const isRefill = (account) => {
+    const cycleEnd = cycleEndMs(account);
+    const deductionEnd = timestamp(account.DeductionEndTime);
+    const descriptor = accountDescriptor(account);
+    const isOneTimePackage = /bonus|gift|trial|赠送|_006_/.test(descriptor);
+    const isRecurringPackage = /free|subscription|recurring|_035_/.test(descriptor);
+    const hasExtendedDeductionWindow = Number.isFinite(cycleEnd)
+      && Number.isFinite(deductionEnd)
+      && deductionEnd - cycleEnd > 2 * 24 * 60 * 60 * 1000;
+    return !isOneTimePackage && (isRecurringPackage || hasExtendedDeductionWindow);
+  };
+
+  const byExpiry = (a, b) => cycleEndMs(a) - cycleEndMs(b);
+  const refills = accounts.filter(isRefill).sort(byExpiry);
+  const bonuses = accounts.filter((account) => !isRefill(account)).sort(byExpiry);
+  const quotas = {};
+
+  const seenRefill = {};
+  for (const account of refills) {
+    const packageName = accountLabel(account);
+    const base = packageName === "Quota" ? refillCadence(account) : packageName;
+    seenRefill[base] = (seenRefill[base] || 0) + 1;
+    const name = seenRefill[base] > 1 ? `${base} ${seenRefill[base]}` : base;
+    quotas[name] = {
+      used: numberValue(account, [
+        "CycleCapacityUsedPrecise",
+        "CycleCapacityUsed",
+        "CapacityUsedPrecise",
+        "CapacityUsed",
+      ]),
+      total: numberValue(account, [
+        "CycleCapacitySizePrecise",
+        "CycleCapacitySize",
+        "CapacitySizePrecise",
+        "CapacitySize",
+      ]),
+      resetAt: parseResetTime(account.CycleEndTime),
+      unlimited: false,
+      recurring: true,
+    };
+  }
+
+  const seenPackages = {};
+  for (const account of bonuses) {
+    const base = accountLabel(account);
+    seenPackages[base] = (seenPackages[base] || 0) + 1;
+    const name = seenPackages[base] > 1 ? `${base} ${seenPackages[base]}` : base;
+    quotas[name] = {
+      used: numberValue(account, [
+        "CapacityUsedPrecise",
+        "CapacityUsed",
+        "CycleCapacityUsedPrecise",
+        "CycleCapacityUsed",
+      ]),
+      total: numberValue(account, [
+        "CapacitySizePrecise",
+        "CapacitySize",
+        "CycleCapacitySizePrecise",
+        "CycleCapacitySize",
+      ]),
+      resetAt: parseResetTime(account.CycleEndTime),
+      unlimited: false,
+      recurring: false,
+    };
+  }
+
+  const basePackage = accounts[0] || {};
+  return {
+    plan: basePackage.PackageName || basePackage.SubProductName || "CodeBuddy",
+    quotas,
+  };
+}
+
+async function getCodeBuddyUsage(providerId, accessToken, apiKey, proxyOptions = null) {
+  const providerName = providerId === "codebuddy-intl" ? "CodeBuddy Intl" : "CodeBuddy CN";
+  const token = accessToken || apiKey;
+  if (!token) {
+    return { message: `${providerName} access token or API key not available.` };
+  }
+
+  try {
+    const response = await fetchWithTimeout(U(providerId).url, {
+      method: "POST",
+      headers: {
+        ...(PROVIDERS[providerId]?.headers || {}),
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json",
+        Accept: "application/json",
+      },
+      body: "{}",
+    }, 10_000, proxyOptions);
+
+    if (response.status === 401 || response.status === 403) {
+      return { message: `${providerName} credential invalid or expired.` };
+    }
+    if (!response.ok) {
+      return { message: `${providerName} usage request failed.` };
+    }
+
+    const json = await response.json();
+    if (json?.code !== 0) {
+      return { message: `${providerName} usage request failed.` };
+    }
+
+    const accounts = extractAccounts(json);
+    if (accounts.length === 0) {
+      return { message: `${providerName} connected. No credit package found.` };
+    }
+
+    return buildCodeBuddyQuotas(accounts);
+  } catch (error) {
+    console.error(`[CodeBuddy Usage] ${providerId} failed:`, error);
+    return { message: "CodeBuddy usage request failed." };
+  }
+}
+
+export async function getCodeBuddyCnUsage(accessToken, apiKey, providerSpecificData, proxyOptions = null) {
+  return getCodeBuddyUsage(PROVIDER_ID, accessToken, apiKey, proxyOptions);
+}
+
+export async function getCodeBuddyIntlUsage(accessToken, apiKey, providerSpecificData, proxyOptions = null) {
+  return getCodeBuddyUsage("codebuddy-intl", accessToken, apiKey, proxyOptions);
+}
+
+export function parseCodeBuddyQuotaResponse(payload) {
+  const accounts = extractAccounts(payload);
+  return buildCodeBuddyQuotas(accounts);
+}