@fudrouter/fsrouter 0.6.64 → 0.6.66

package/open-sse/services/usage/codex.js

@@ -0,0 +1,267 @@
+/**
+ * Codex (OpenAI / ChatGPT backend) usage handler
+ * Updated from OmniRoute — supports dual-window quota, code_review, spark, bankedResetCredits
+ */
+
+import { proxyAwareFetch } from "../../utils/proxyFetch.js";
+
+// Codex (OpenAI) API config — uses /wham/usage (newer endpoint)
+const CODEX_CONFIG = {
+  usageUrl: "https://chatgpt.com/backend-api/wham/usage",
+};
+
+function getFieldValue(record, ...keys) {
+  if (!record || typeof record !== "object") return null;
+  for (const key of keys) {
+    if (record[key] !== undefined && record[key] !== null) return record[key];
+  }
+  return null;
+}
+
+function toRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+
+function toNumber(value, fallback = 0) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim().length > 0) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : fallback;
+  }
+  return fallback;
+}
+
+function parseResetTime(resetValue) {
+  if (!resetValue) return null;
+  try {
+    let date = null;
+    if (resetValue instanceof Date) {
+      date = resetValue;
+    } else if (typeof resetValue === "number") {
+      date = new Date(resetValue < 1e12 ? resetValue * 1000 : resetValue);
+    } else if (typeof resetValue === "string") {
+      if (/^\d+$/.test(resetValue)) {
+        const ts = Number(resetValue);
+        date = new Date(ts < 1e12 ? ts * 1000 : ts);
+      } else {
+        date = new Date(resetValue);
+      }
+    }
+    if (!date || date.getTime() <= 0) return null;
+    return date.toISOString();
+  } catch {
+    return null;
+  }
+}
+
+function parseWindowReset(window) {
+  const resetAt = toNumber(getFieldValue(window, "reset_at", "resetAt"), 0);
+  const resetAfterSeconds = toNumber(getFieldValue(window, "reset_after_seconds", "resetAfterSeconds"), 0);
+  if (resetAt > 0) return parseResetTime(resetAt * 1000);
+  if (resetAfterSeconds > 0) return parseResetTime(Date.now() + resetAfterSeconds * 1000);
+  return null;
+}
+
+function buildPercentageQuota(window, displayName) {
+  const usedPercent = toNumber(getFieldValue(window, "used_percent", "usedPercent"), 0);
+  return {
+    used: usedPercent,
+    total: 100,
+    remaining: 100 - usedPercent,
+    resetAt: parseWindowReset(window),
+    unlimited: false,
+    ...(displayName ? { displayName } : {}),
+  };
+}
+
+function isCodexReviewLimitDescriptor(...values) {
+  return values.some((value) => {
+    if (typeof value !== "string") return false;
+    const normalized = value.trim().toLowerCase();
+    if (!normalized) return false;
+    return (
+      normalized === "code_review" ||
+      normalized === "codex_review" ||
+      normalized === "review" ||
+      normalized.includes("code_review") ||
+      normalized.includes("codex_review") ||
+      normalized.includes("code review")
+    );
+  });
+}
+
+function findCodexReviewRateLimit(data) {
+  const additionalRateLimits = getFieldValue(data, "additional_rate_limits", "additionalRateLimits");
+  if (!Array.isArray(additionalRateLimits)) return {};
+  for (const entry of additionalRateLimits) {
+    const rec = toRecord(entry);
+    if (
+      isCodexReviewLimitDescriptor(
+        getFieldValue(rec, "limit_name", "limitName"),
+        getFieldValue(rec, "metered_feature", "meteredFeature"),
+        getFieldValue(rec, "limit_id", "limitId"),
+        rec["id"], rec["name"]
+      )
+    ) {
+      return toRecord(getFieldValue(rec, "rate_limit", "rateLimit"));
+    }
+  }
+  return {};
+}
+
+function isCodexSparkLimitDescriptor(...values) {
+  return values.some((value) => {
+    if (typeof value !== "string") return false;
+    const normalized = value.trim().toLowerCase();
+    return normalized === "spark" || normalized.includes("spark");
+  });
+}
+
+function findCodexSparkRateLimit(data) {
+  const additionalRateLimits = getFieldValue(data, "additional_rate_limits", "additionalRateLimits");
+  if (!Array.isArray(additionalRateLimits)) return {};
+  for (const entry of additionalRateLimits) {
+    const rec = toRecord(entry);
+    if (
+      isCodexSparkLimitDescriptor(
+        getFieldValue(rec, "limit_name", "limitName"),
+        getFieldValue(rec, "metered_feature", "meteredFeature"),
+        getFieldValue(rec, "limit_id", "limitId"),
+        rec["id"], rec["name"], rec["model"],
+        getFieldValue(rec, "model_id", "modelId")
+      )
+    ) {
+      return toRecord(getFieldValue(rec, "rate_limit", "rateLimit"));
+    }
+  }
+  return {};
+}
+
+function parseBankedResetCredits(data) {
+  const resetCredits = toRecord(getFieldValue(data, "rate_limit_reset_credits", "rateLimitResetCredits"));
+  const availableCount = getFieldValue(resetCredits, "available_count", "availableCount");
+  const count = toNumber(availableCount, NaN);
+  return Number.isFinite(count) ? count : undefined;
+}
+
+function parseRateLimitReachedType(data) {
+  const reachedType = getFieldValue(data, "rate_limit_reached_type", "rateLimitReachedType");
+  if (typeof reachedType === "string" && reachedType.trim().length > 0) return reachedType.trim();
+  const reachedTypeObj = toRecord(reachedType);
+  const type = getFieldValue(reachedTypeObj, "type");
+  return typeof type === "string" && type.trim().length > 0 ? type.trim() : undefined;
+}
+
+/**
+ * Build Codex usage quotas from /wham/usage response.
+ * Supports: session (5h), weekly (7d), code_review, code_review_weekly, spark, spark_weekly
+ */
+function buildCodexUsageQuotas(dataValue) {
+  const data = toRecord(dataValue);
+  const rateLimit = toRecord(getFieldValue(data, "rate_limit", "rateLimit"));
+  const quotas = {};
+  const bankedResetCredits = parseBankedResetCredits(data);
+  const rateLimitReachedType = parseRateLimitReachedType(data);
+
+  // Primary window (5h session)
+  const primaryWindow = toRecord(getFieldValue(rateLimit, "primary_window", "primaryWindow"));
+  if (Object.keys(primaryWindow).length > 0) quotas.session = buildPercentageQuota(primaryWindow);
+
+  // Secondary window (7d weekly)
+  const secondaryWindow = toRecord(getFieldValue(rateLimit, "secondary_window", "secondaryWindow"));
+  if (Object.keys(secondaryWindow).length > 0) quotas.weekly = buildPercentageQuota(secondaryWindow);
+
+  // Code review rate limit (dedicated block or additional_rate_limits fallback)
+  const dedicatedReviewRateLimit = toRecord(getFieldValue(data, "code_review_rate_limit", "codeReviewRateLimit"));
+  const reviewRateLimit = Object.keys(dedicatedReviewRateLimit).length > 0
+    ? dedicatedReviewRateLimit
+    : findCodexReviewRateLimit(data);
+
+  const codeReviewWindow = toRecord(getFieldValue(reviewRateLimit, "primary_window", "primaryWindow"));
+  if (getFieldValue(codeReviewWindow, "used_percent", "usedPercent") !== null ||
+      getFieldValue(codeReviewWindow, "remaining_count", "remainingCount") !== null) {
+    quotas.code_review = buildPercentageQuota(codeReviewWindow);
+  }
+
+  const codeReviewSecondaryWindow = toRecord(getFieldValue(reviewRateLimit, "secondary_window", "secondaryWindow"));
+  if (getFieldValue(codeReviewSecondaryWindow, "used_percent", "usedPercent") !== null ||
+      getFieldValue(codeReviewSecondaryWindow, "remaining_count", "remainingCount") !== null) {
+    quotas.code_review_weekly = buildPercentageQuota(codeReviewSecondaryWindow);
+  }
+
+  // Spark quota (additional_rate_limits)
+  const sparkRateLimit = findCodexSparkRateLimit(data);
+  const sparkPrimaryWindow = toRecord(getFieldValue(sparkRateLimit, "primary_window", "primaryWindow"));
+  if (Object.keys(sparkPrimaryWindow).length > 0) {
+    quotas.spark = buildPercentageQuota(sparkPrimaryWindow, "Spark");
+  }
+  const sparkSecondaryWindow = toRecord(getFieldValue(sparkRateLimit, "secondary_window", "secondaryWindow"));
+  if (Object.keys(sparkSecondaryWindow).length > 0) {
+    quotas.spark_weekly = buildPercentageQuota(sparkSecondaryWindow, "Spark Weekly");
+  }
+
+  return { rateLimit, quotas, bankedResetCredits, rateLimitReachedType };
+}
+
+/**
+ * Codex (OpenAI) Usage - Fetch from ChatGPT /wham/usage API
+ * Uses persisted workspaceId from OAuth for correct workspace binding.
+ */
+export async function getCodexUsage(accessToken, providerSpecificData = {}) {
+  try {
+    const accountId = typeof providerSpecificData?.workspaceId === "string"
+      ? providerSpecificData.workspaceId
+      : null;
+
+    const headers = {
+      Authorization: `Bearer ${accessToken}`,
+      "Content-Type": "application/json",
+      Accept: "application/json",
+    };
+    if (accountId) {
+      headers["chatgpt-account-id"] = accountId;
+    }
+
+    const response = await proxyAwareFetch(CODEX_CONFIG.usageUrl, {
+      method: "GET",
+      headers,
+    });
+
+    if (!response.ok) {
+      if (response.status === 401 || response.status === 403) {
+        return {
+          message: "Codex token expired or access denied. Please re-authenticate the connection.",
+        };
+      }
+      throw new Error(`Codex API error: ${response.status}`);
+    }
+
+    const data = await response.json();
+    const { rateLimit, quotas, bankedResetCredits, rateLimitReachedType } = buildCodexUsageQuotas(data);
+
+    return {
+      plan: String(getFieldValue(data, "plan_type", "planType") || "unknown"),
+      limitReached: Boolean(getFieldValue(rateLimit, "limit_reached", "limitReached")),
+      quotas,
+      ...(bankedResetCredits !== undefined ? { bankedResetCredits } : {}),
+      ...(rateLimitReachedType !== undefined ? { rateLimitReachedType } : {}),
+    };
+  } catch (error) {
+    return { message: `Failed to fetch Codex usage: ${error.message}` };
+  }
+}
+
+// Stub: consume a banked reset credit (display-only, not implemented in AMRouter)
+export async function consumeCodexRateLimitResetCredit(accessToken, providerSpecificData = {}) {
+  return { success: false, message: "Reset credit consumption not supported" };
+}
+
+// Stub: get banked reset credits
+export async function getCodexRateLimitResetCredits(accessToken, providerSpecificData = {}) {
+  try {
+    const result = await getCodexUsage(accessToken, providerSpecificData);
+    return { credits: result.bankedResetCredits || 0 };
+  } catch {
+    return { credits: 0 };
+  }
+}

package/open-sse/services/usage/github.js

@@ -0,0 +1,100 @@
+/**
+ * GitHub Copilot usage handler
+ */
+
+import { proxyAwareFetch } from "../../utils/proxyFetch.js";
+import { PROVIDER_OAUTH } from "../../providers/index.js";
+import { U, parseResetTime } from "./shared.js";
+
+// GitHub API config — single source from registry oauth block
+const GITHUB_CONFIG = {
+  apiVersion: PROVIDER_OAUTH.github?.apiVersion,
+  userAgent: PROVIDER_OAUTH.github?.userAgent,
+};
+
+/**
+ * GitHub Copilot Usage
+ * Uses GitHub accessToken (not copilotToken) to call copilot_internal/user API
+ */
+export async function getGitHubUsage(accessToken, providerSpecificData, proxyOptions = null) {
+  try {
+    if (!accessToken) {
+      throw new Error("No GitHub access token available. Please re-authorize the connection.");
+    }
+
+    // copilot_internal/user API requires GitHub OAuth token, not copilotToken
+    const response = await proxyAwareFetch(U("github").url, {
+      headers: {
+        "Authorization": `token ${accessToken}`,
+        "Accept": "application/json",
+        "X-GitHub-Api-Version": GITHUB_CONFIG.apiVersion,
+        "User-Agent": GITHUB_CONFIG.userAgent,
+        "Editor-Version": "vscode/1.100.0",
+        "Editor-Plugin-Version": "copilot-chat/0.26.7",
+      },
+    }, proxyOptions);
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`GitHub API error: ${error}`);
+    }
+
+    const data = await response.json();
+
+    // Handle different response formats (paid vs free)
+    if (data.quota_snapshots) {
+      // Paid plan format
+      const snapshots = data.quota_snapshots;
+      const resetAt = parseResetTime(data.quota_reset_date);
+
+      return {
+        plan: data.copilot_plan,
+        resetDate: data.quota_reset_date,
+        quotas: {
+          chat: { ...formatGitHubQuotaSnapshot(snapshots.chat), resetAt },
+          completions: { ...formatGitHubQuotaSnapshot(snapshots.completions), resetAt },
+          premium_interactions: { ...formatGitHubQuotaSnapshot(snapshots.premium_interactions), resetAt },
+        },
+      };
+    } else if (data.monthly_quotas || data.limited_user_quotas) {
+      // Free/limited plan format
+      const monthlyQuotas = data.monthly_quotas || {};
+      const usedQuotas = data.limited_user_quotas || {};
+      const resetAt = parseResetTime(data.limited_user_reset_date);
+
+      return {
+        plan: data.copilot_plan || data.access_type_sku,
+        resetDate: data.limited_user_reset_date,
+        quotas: {
+          chat: {
+            used: usedQuotas.chat || 0,
+            total: monthlyQuotas.chat || 0,
+            unlimited: false,
+            resetAt,
+          },
+          completions: {
+            used: usedQuotas.completions || 0,
+            total: monthlyQuotas.completions || 0,
+            unlimited: false,
+            resetAt,
+          },
+        },
+      };
+    }
+
+    return { message: "GitHub Copilot connected. Unable to parse quota data." };
+  } catch (error) {
+    throw new Error(`Failed to fetch GitHub usage: ${error.message}`);
+  }
+}
+
+function formatGitHubQuotaSnapshot(quota) {
+  if (!quota) return { used: 0, total: 0, unlimited: true };
+
+  return {
+    used: quota.entitlement - quota.remaining,
+    total: quota.entitlement,
+    remaining: quota.remaining,
+    unlimited: quota.unlimited || false,
+  };
+}

package/open-sse/services/usage/google.js

@@ -0,0 +1,241 @@
+/**
+ * Google usage handlers (Gemini CLI + Antigravity)
+ */
+
+import { CLIENT_METADATA } from "../../config/appConstants.js";
+import { ANTIGRAVITY_IDE_USER_AGENT, ANTIGRAVITY_IDE_VERSION, ANTIGRAVITY_OAUTH_CLIENT } from "../../providers/shared.js";
+import { U, parseResetTime, normalizeCloudCodeProjectId, fetchWithTimeout } from "./shared.js";
+
+// Antigravity API config (from Quotio) — urls from registry, oauth client + dynamic UA kept here
+const ANTIGRAVITY_CONFIG = {
+  ...U("antigravity"),
+  ...ANTIGRAVITY_OAUTH_CLIENT,
+  userAgent: ANTIGRAVITY_IDE_USER_AGENT,
+};
+
+/**
+ * Gemini CLI Usage — fetch per-model quota via Cloud Code Assist API.
+ * Uses retrieveUserQuota (same endpoint as `gemini /stats`) returning
+ * per-model buckets with remainingFraction + resetTime.
+ */
+export async function getGeminiUsage(accessToken, providerSpecificData, proxyOptions = null) {
+  if (!accessToken) {
+    return { plan: "Free", message: "Gemini CLI access token not available." };
+  }
+
+  try {
+    // Resolve project id: prefer connection-stored id, else loadCodeAssist lookup.
+    // #1271: OAuth save stores projectId on the connection, not providerSpecificData.
+    let projectId = normalizeCloudCodeProjectId(providerSpecificData?.projectId);
+    let plan = "Free";
+
+    if (!projectId) {
+      const subInfo = await getGeminiSubscriptionInfo(accessToken, proxyOptions);
+      projectId = normalizeCloudCodeProjectId(subInfo?.cloudaicompanionProject);
+      plan = subInfo?.currentTier?.name || plan;
+    }
+
+    if (!projectId) {
+      return {
+        plan,
+        message: "Gemini CLI project ID not available. Reconnect Gemini CLI, or configure a Google Cloud project with Gemini Code Assist access before checking quota.",
+      };
+    }
+
+    const response = await fetchWithTimeout(
+      U("gemini-cli").quotaUrl,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ project: projectId }),
+      },
+      10000,
+      proxyOptions
+    );
+
+    if (!response.ok) {
+      return { plan, message: `Gemini CLI quota error (${response.status}).` };
+    }
+
+    const data = await response.json();
+    const quotas = {};
+
+    if (Array.isArray(data.buckets)) {
+      for (const bucket of data.buckets) {
+        if (!bucket.modelId || bucket.remainingFraction == null) continue;
+
+        const remainingFraction = Number(bucket.remainingFraction) || 0;
+        const total = 1000; // Normalized base, matches antigravity convention
+        const remaining = Math.round(total * remainingFraction);
+        const used = Math.max(0, total - remaining);
+
+        quotas[bucket.modelId] = {
+          used,
+          total,
+          resetAt: parseResetTime(bucket.resetTime),
+          remainingPercentage: remainingFraction * 100,
+          unlimited: false,
+        };
+      }
+    }
+
+    return { plan, quotas };
+  } catch (error) {
+    return { message: `Gemini CLI error: ${error.message}` };
+  }
+}
+
+/**
+ * Get Gemini CLI subscription info via loadCodeAssist
+ */
+async function getGeminiSubscriptionInfo(accessToken, proxyOptions = null) {
+  try {
+    const response = await fetchWithTimeout(
+      U("gemini-cli").loadCodeAssistUrl,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ metadata: CLIENT_METADATA }),
+      },
+      10000,
+      proxyOptions
+    );
+    if (!response.ok) return null;
+    return await response.json();
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Antigravity Usage - Fetch quota from Google Cloud Code API
+ */
+export async function getAntigravityUsage(accessToken, providerSpecificData, proxyOptions = null) {
+  try {
+    // Fetch subscription info once — reuse for both projectId and plan
+    const subscriptionInfo = await getAntigravitySubscriptionInfo(accessToken, proxyOptions);
+    const projectId = subscriptionInfo?.cloudaicompanionProject || null;
+
+    const response = await fetchWithTimeout(ANTIGRAVITY_CONFIG.quotaApiUrl, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${accessToken}`,
+        "User-Agent": ANTIGRAVITY_CONFIG.userAgent,
+        "Content-Type": "application/json",
+        "X-Client-Name": "antigravity",
+        "X-Client-Version": ANTIGRAVITY_IDE_VERSION,
+      },
+      body: JSON.stringify({
+        ...(projectId ? { project: projectId } : {})
+      }),
+    }, 10000, proxyOptions);
+
+    if (response.status === 403) {
+      return {
+        message: "Antigravity quota API access forbidden. Chat may still work.",
+        quotas: {}
+      };
+    }
+
+    if (response.status === 401) {
+      return {
+        message: "Antigravity quota API authentication expired. Chat may still work.",
+        quotas: {}
+      };
+    }
+
+    if (!response.ok) {
+      throw new Error(`Antigravity API error: ${response.status}`);
+    }
+
+    const data = await response.json();
+    const quotas = {};
+
+    // Parse model quotas (inspired by vscode-antigravity-cockpit)
+    if (data.models) {
+      // Filter only recommended/important models (must match PROVIDER_MODELS ag ids)
+      const importantModels = [
+        'gemini-3-flash-agent',
+        'gemini-3.5-flash-low',
+        'gemini-3.5-flash-extra-low',
+        'gemini-pro-agent',
+        'gemini-3.1-pro-low',
+        'claude-sonnet-4-6',
+        'claude-opus-4-6-thinking',
+        'gpt-oss-120b-medium',
+        'gemini-3-flash',
+        // Image generation models
+        'gemini-3.1-flash-image',
+        'gemini-3-pro-image',
+      ];
+
+      for (const [modelKey, info] of Object.entries(data.models)) {
+        // Skip models without quota info
+        if (!info.quotaInfo) {
+          continue;
+        }
+
+        // Skip internal models and non-important models
+        if (info.isInternal || !importantModels.includes(modelKey)) {
+          continue;
+        }
+
+        const remainingFraction = info.quotaInfo.remainingFraction || 0;
+        const remainingPercentage = remainingFraction * 100;
+
+        // Convert percentage to used/total for UI compatibility
+        const total = 1000; // Normalized base
+        const remaining = Math.round(total * remainingFraction);
+        const used = total - remaining;
+
+        // Use modelKey as key (matches PROVIDER_MODELS id)
+        quotas[modelKey] = {
+          used,
+          total,
+          resetAt: parseResetTime(info.quotaInfo.resetTime),
+          remainingPercentage,
+          unlimited: false,
+          displayName: info.displayName || modelKey,
+        };
+      }
+    }
+
+    return {
+      plan: subscriptionInfo?.currentTier?.name || "Unknown",
+      quotas,
+      subscriptionInfo,
+    };
+  } catch (error) {
+    console.error("[Antigravity Usage] Error:", error.message, error.cause);
+    return { message: `Antigravity error: ${error.message}` };
+  }
+}
+
+/**
+ * Get Antigravity subscription info
+ */
+async function getAntigravitySubscriptionInfo(accessToken, proxyOptions = null) {
+  try {
+    const response = await fetchWithTimeout(ANTIGRAVITY_CONFIG.loadProjectApiUrl, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${accessToken}`,
+        "User-Agent": ANTIGRAVITY_CONFIG.userAgent,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ metadata: CLIENT_METADATA, mode: 1 }),
+    }, 10000, proxyOptions);
+
+    if (!response.ok) return null;
+    return await response.json();
+  } catch (error) {
+    console.error("[Antigravity Subscription] Error:", error.message);
+    return null;
+  }
+}