@fudrouter/fsrouter 0.6.64 → 0.6.66

package/open-sse/services/accountFallback.js

@@ -0,0 +1,323 @@
+import { ERROR_RULES, BACKOFF_CONFIG, TRANSIENT_COOLDOWN_MS } from "../config/errorConfig.js";
+
+/**
+ * Calculate exponential backoff cooldown for rate limits (429)
+ * Level 1: 1s, Level 2: 2s, Level 3: 4s... → max 4 min
+ * @param {number} backoffLevel - Current backoff level
+ * @returns {number} Cooldown in milliseconds
+ */
+export function getQuotaCooldown(backoffLevel = 0) {
+  const level = Math.max(0, backoffLevel - 1);
+  const cooldown = BACKOFF_CONFIG.base * Math.pow(2, level);
+  return Math.min(cooldown, BACKOFF_CONFIG.max);
+}
+
+/**
+ * Check if error should trigger account fallback (switch to next account)
+ * Config-driven: matches ERROR_RULES top-to-bottom (text rules first, then status)
+ * @param {number} status - HTTP status code
+ * @param {string} errorText - Error message text
+ * @param {number} backoffLevel - Current backoff level for exponential backoff
+ * @returns {{ shouldFallback: boolean, cooldownMs: number, newBackoffLevel?: number }}
+ */
+export function checkFallbackError(status, errorText, backoffLevel = 0) {
+  const lowerError = errorText
+    ? (typeof errorText === "string" ? errorText : JSON.stringify(errorText)).toLowerCase()
+    : "";
+
+  for (const rule of ERROR_RULES) {
+    // Text-based rule: match substring in error message
+    if (rule.text && lowerError && lowerError.includes(rule.text)) {
+      if (rule.backoff) {
+        const newLevel = Math.min(backoffLevel + 1, BACKOFF_CONFIG.maxLevel);
+        return { shouldFallback: true, cooldownMs: getQuotaCooldown(newLevel), newBackoffLevel: newLevel };
+      }
+      return { shouldFallback: true, cooldownMs: rule.cooldownMs };
+    }
+
+    // Status-based rule: match HTTP status code
+    if (rule.status && rule.status === status) {
+      if (rule.backoff) {
+        const newLevel = Math.min(backoffLevel + 1, BACKOFF_CONFIG.maxLevel);
+        return { shouldFallback: true, cooldownMs: getQuotaCooldown(newLevel), newBackoffLevel: newLevel };
+      }
+      return { shouldFallback: true, cooldownMs: rule.cooldownMs };
+    }
+  }
+
+  // Default: transient cooldown for any unmatched error
+  return { shouldFallback: true, cooldownMs: TRANSIENT_COOLDOWN_MS };
+}
+
+/**
+ * Check if account is currently unavailable (cooldown not expired)
+ */
+export function isAccountUnavailable(unavailableUntil) {
+  if (!unavailableUntil) return false;
+  return new Date(unavailableUntil).getTime() > Date.now();
+}
+
+/**
+ * Calculate unavailable until timestamp
+ */
+export function getUnavailableUntil(cooldownMs) {
+  return new Date(Date.now() + cooldownMs).toISOString();
+}
+
+/**
+ * Get the earliest rateLimitedUntil from a list of accounts
+ * @param {Array} accounts - Array of account objects with rateLimitedUntil
+ * @returns {string|null} Earliest rateLimitedUntil ISO string, or null
+ */
+export function getEarliestRateLimitedUntil(accounts) {
+  let earliest = null;
+  const now = Date.now();
+  for (const acc of accounts) {
+    if (!acc.rateLimitedUntil) continue;
+    const until = new Date(acc.rateLimitedUntil).getTime();
+    if (until <= now) continue;
+    if (!earliest || until < earliest) earliest = until;
+  }
+  if (!earliest) return null;
+  return new Date(earliest).toISOString();
+}
+
+/**
+ * Format rateLimitedUntil to human-readable "reset after Xm Ys"
+ * @param {string} rateLimitedUntil - ISO timestamp
+ * @returns {string} e.g. "reset after 2m 30s"
+ */
+export function formatRetryAfter(rateLimitedUntil) {
+  if (!rateLimitedUntil) return "";
+  const diffMs = new Date(rateLimitedUntil).getTime() - Date.now();
+  if (diffMs <= 0) return "reset after 0s";
+  const totalSec = Math.ceil(diffMs / 1000);
+  const h = Math.floor(totalSec / 3600);
+  const m = Math.floor((totalSec % 3600) / 60);
+  const s = totalSec % 60;
+  const parts = [];
+  if (h > 0) parts.push(`${h}h`);
+  if (m > 0) parts.push(`${m}m`);
+  if (s > 0 || parts.length === 0) parts.push(`${s}s`);
+  return `reset after ${parts.join(" ")}`;
+}
+
+/** Prefix for model lock flat fields on connection record */
+export const MODEL_LOCK_PREFIX = "modelLock_";
+
+/** Special key used when no model is known (account-level lock) */
+export const MODEL_LOCK_ALL = `${MODEL_LOCK_PREFIX}__all`;
+
+/** Build the flat field key for a model lock */
+export function getModelLockKey(model) {
+  return model ? `${MODEL_LOCK_PREFIX}${model}` : MODEL_LOCK_ALL;
+}
+
+/**
+ * Check if a model lock on a connection is still active.
+ * Reads flat field `modelLock_${model}` (or `modelLock___all` when model=null).
+ */
+export function isModelLockActive(connection, model) {
+  const key = getModelLockKey(model);
+  const expiry = connection[key] || connection[MODEL_LOCK_ALL];
+  if (!expiry) return false;
+  return new Date(expiry).getTime() > Date.now();
+}
+
+/**
+ * Get earliest active model lock expiry across all modelLock_* fields.
+ * Used for UI cooldown display.
+ */
+export function getEarliestModelLockUntil(connection) {
+  if (!connection) return null;
+  let earliest = null;
+  const now = Date.now();
+  for (const [key, val] of Object.entries(connection)) {
+    if (!key.startsWith(MODEL_LOCK_PREFIX) || !val) continue;
+    const t = new Date(val).getTime();
+    if (t <= now) continue;
+    if (!earliest || t < earliest) earliest = t;
+  }
+  return earliest ? new Date(earliest).toISOString() : null;
+}
+
+/**
+ * Build update object to set a model lock on a connection.
+ */
+export function buildModelLockUpdate(model, cooldownMs) {
+  const key = getModelLockKey(model);
+  return { [key]: new Date(Date.now() + cooldownMs).toISOString() };
+}
+
+/**
+ * Build update object to clear all model locks on a connection.
+ */
+export function buildClearModelLocksUpdate(connection) {
+  const cleared = {};
+  for (const key of Object.keys(connection)) {
+    if (key.startsWith(MODEL_LOCK_PREFIX)) cleared[key] = null;
+  }
+  return cleared;
+}
+
+/**
+ * Filter available accounts (not in cooldown)
+ */
+export function filterAvailableAccounts(accounts, excludeId = null) {
+  const now = Date.now();
+  return accounts.filter(acc => {
+    if (excludeId && acc.id === excludeId) return false;
+    if (acc.rateLimitedUntil) {
+      const until = new Date(acc.rateLimitedUntil).getTime();
+      if (until > now) return false;
+    }
+    return true;
+  });
+}
+
+/**
+ * Reset account state when request succeeds
+ * Clears cooldown and resets backoff level to 0
+ * @param {object} account - Account object
+ * @returns {object} Updated account with reset state
+ */
+export function resetAccountState(account) {
+  if (!account) return account;
+  return {
+    ...account,
+    rateLimitedUntil: null,
+    backoffLevel: 0,
+    lastError: null,
+    status: "active"
+  };
+}
+
+/**
+ * Apply error state to account
+ * @param {object} account - Account object
+ * @param {number} status - HTTP status code
+ * @param {string} errorText - Error message
+ * @returns {object} Updated account with error state
+ */
+export function applyErrorState(account, status, errorText) {
+  if (!account) return account;
+
+  const backoffLevel = account.backoffLevel || 0;
+  const { cooldownMs, newBackoffLevel } = checkFallbackError(status, errorText, backoffLevel);
+
+  return {
+    ...account,
+    rateLimitedUntil: cooldownMs > 0 ? getUnavailableUntil(cooldownMs) : null,
+    backoffLevel: newBackoffLevel ?? backoffLevel,
+    lastError: { status, message: errorText, timestamp: new Date().toISOString() },
+    status: "error"
+  };
+}
+
+// ── Error classification stubs (used by errorClassifier.js) ─────────────────
+
+/**
+ * Check if error text indicates the account has been deactivated/disabled.
+ */
+export function isAccountDeactivated(text) {
+  if (!text || typeof text !== 'string') return false;
+  const lower = text.toLowerCase();
+  return (
+    lower.includes('account disabled') ||
+    lower.includes('account_deactivated') ||
+    lower.includes('account has been deactivated') ||
+    lower.includes('account is no longer active') ||
+    lower.includes('organization has been disabled')
+  );
+}
+
+/**
+ * Check if error text indicates credits/billing exhaustion.
+ */
+export function isCreditsExhausted(text) {
+  if (!text || typeof text !== 'string') return false;
+  const lower = text.toLowerCase();
+  return (
+    lower.includes('insufficient funds') ||
+    lower.includes('insufficient_funds') ||
+    lower.includes('credits exhausted') ||
+    lower.includes('out of credits') ||
+    lower.includes('no credits') ||
+    lower.includes('credit limit') ||
+    lower.includes('payment required') ||
+    lower.includes('spending limit') ||
+    lower.includes('quota exceeded') ||
+    lower.includes('quota_exceeded') ||
+    lower.includes('budget exceeded') ||
+    lower.includes('budget_exceeded')
+  );
+}
+
+/**
+ * Check if error text indicates daily quota exhaustion (for 429 responses).
+ */
+export function isDailyQuotaExhausted(text) {
+  if (!text || typeof text !== 'string') return false;
+  const lower = text.toLowerCase();
+  return (
+    lower.includes('daily') ||
+    lower.includes('per day') ||
+    lower.includes('daily limit') ||
+    lower.includes('rate limit reached') ||
+    lower.includes('daily quota')
+  );
+}
+
+/**
+ * Check if error text indicates an invalid/expired OAuth token.
+ */
+export function isOAuthInvalidToken(text) {
+  if (!text || typeof text !== 'string') return false;
+  const lower = text.toLowerCase();
+  return (
+    lower.includes('invalid_token') ||
+    lower.includes('invalid token') ||
+    lower.includes('token expired') ||
+    lower.includes('token has expired') ||
+    lower.includes('access token is invalid')
+  );
+}
+
+/**
+ * Parse retry-after from a response body (JSON or string).
+ * Returns { retryAfterMs, reason }.
+ */
+export function parseRetryAfterFromBody(responseBody) {
+  if (!responseBody) return { retryAfterMs: 0, reason: null };
+  const text = typeof responseBody === 'string' ? responseBody : JSON.stringify(responseBody);
+
+  let retryAfterMs = 0;
+  let reason = null;
+
+  if (typeof responseBody === 'object' && responseBody !== null) {
+    const raw = responseBody.retry_after ?? responseBody.retryAfter ?? responseBody.retry_after_seconds;
+    if (typeof raw === 'number' && raw > 0) {
+      retryAfterMs = raw < 1e12 ? raw * 1000 : raw - Date.now();
+      reason = 'retry_after header';
+    } else if (typeof raw === 'string') {
+      const parsed = Number(raw);
+      if (Number.isFinite(parsed) && parsed > 0) {
+        retryAfterMs = parsed < 1e12 ? parsed * 1000 : parsed - Date.now();
+        reason = 'retry_after header';
+      }
+    }
+  }
+
+  if (retryAfterMs === 0) {
+    const match = text.match(/retry.*?(\d+)\s*(?:second|minute|hour)/i);
+    if (match) {
+      const val = Number(match[1]);
+      if (text.includes('minute')) retryAfterMs = val * 60 * 1000;
+      else if (text.includes('hour')) retryAfterMs = val * 3600 * 1000;
+      else retryAfterMs = val * 1000;
+      reason = 'body text pattern';
+    }
+  }
+
+  return { retryAfterMs, reason };
+}

package/open-sse/services/antigravityHeaders.js

@@ -0,0 +1,91 @@
+import { platform, arch } from "os";
+import {
+  ANTIGRAVITY_FALLBACK_VERSION,
+  getCachedAntigravityVersion,
+  resolveAntigravityVersion,
+} from "./antigravityVersion.js";
+
+const ANTIGRAVITY_VERSION = ANTIGRAVITY_FALLBACK_VERSION;
+export const ANTIGRAVITY_CHROME_VERSION = "142.0.7444.175";
+export const ANTIGRAVITY_ELECTRON_VERSION = "39.2.3";
+export const ANTIGRAVITY_LOAD_CODE_ASSIST_USER_AGENT = `vscode/1.X.X (Antigravity/${ANTIGRAVITY_FALLBACK_VERSION})`;
+export const ANTIGRAVITY_LOAD_CODE_ASSIST_API_CLIENT = "";
+export const ANTIGRAVITY_NODE_API_CLIENT = "google-api-nodejs-client/10.3.0";
+export const ANTIGRAVITY_CREDIT_PROBE_API_CLIENT = "gl-node/22.21.1";
+export const ANTIGRAVITY_API_CLIENT = ANTIGRAVITY_CREDIT_PROBE_API_CLIENT;
+
+function withOptionalBearerAuth(headers, accessToken) {
+  if (accessToken) {
+    headers.Authorization = `Bearer ${accessToken}`;
+  }
+  return headers;
+}
+
+function getAntigravityPlatformInfo(platformName = platform()) {
+  switch (platformName) {
+    case "darwin":
+      return "Macintosh; Intel Mac OS X 10_15_7";
+    case "win32":
+      return "Windows NT 10.0; Win64; x64";
+    case "linux":
+    default:
+      return "X11; Linux x86_64";
+  }
+}
+
+export function antigravityUserAgent(version = getCachedAntigravityVersion(), platformName = platform()) {
+  return `Antigravity/${version} (${getAntigravityPlatformInfo(platformName)}) Chrome/${ANTIGRAVITY_CHROME_VERSION} Electron/${ANTIGRAVITY_ELECTRON_VERSION}`;
+}
+
+export async function resolveAntigravityUserAgent(platformName = platform()) {
+  const version = await resolveAntigravityVersion();
+  return antigravityUserAgent(version, platformName);
+}
+
+export function antigravityNativeOAuthUserAgent() {
+  return `vscode/1.X.X (Antigravity/${getCachedAntigravityVersion()})`;
+}
+
+export function getAntigravityLoadCodeAssistMetadata() {
+  return {
+    ideType: "ANTIGRAVITY",
+  };
+}
+
+export function getAntigravityLoadCodeAssistClientMetadata() {
+  return JSON.stringify(getAntigravityLoadCodeAssistMetadata());
+}
+
+export function getAntigravityHeaders(profile, accessToken) {
+  switch (profile) {
+    case "loadCodeAssist":
+      return withOptionalBearerAuth(
+        {
+          "Content-Type": "application/json",
+          "User-Agent": antigravityNativeOAuthUserAgent(),
+        },
+        accessToken
+      );
+    case "fetchAvailableModels":
+    case "models":
+      return withOptionalBearerAuth(
+        {
+          "Content-Type": "application/json",
+          "User-Agent": antigravityUserAgent(),
+        },
+        accessToken
+      );
+    default:
+      return withOptionalBearerAuth({ "Content-Type": "application/json" }, accessToken);
+  }
+}
+
+export function getAntigravityCreditProbeApiClientHeader() {
+  return ANTIGRAVITY_CREDIT_PROBE_API_CLIENT;
+}
+
+export function getAntigravityApiClientHeader() {
+  return ANTIGRAVITY_API_CLIENT;
+}
+
+export { ANTIGRAVITY_VERSION };

package/open-sse/services/antigravityVersion.js

@@ -0,0 +1,154 @@
+const ANTIGRAVITY_RELEASE_FEED_URL =
+  "https://antigravity-auto-updater-974169037036.us-central1.run.app/releases";
+const ANTIGRAVITY_GITHUB_RELEASE_URL =
+  "https://api.github.com/repos/antigravityide/antigravity/releases/latest";
+
+export const ANTIGRAVITY_VERSION_CACHE_TTL_MS = 6 * 60 * 60 * 1000;
+export const ANTIGRAVITY_VERSION_FETCH_TIMEOUT_MS = 5000;
+// Floor version synced with Antigravity-Manager v4.2.0 KNOWN_STABLE_VERSION.
+export const ANTIGRAVITY_FALLBACK_VERSION = "4.2.0";
+
+let versionCache = null;
+let inFlightRequest = null;
+
+function normalizeVersion(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim().replace(/^v/i, "");
+  const match = trimmed.match(/^(\d+\.\d+\.\d+)\b/);
+  return match ? match[1] : null;
+}
+
+function compareSemver(a, b) {
+  const aParts = a.split(".").map((part) => Number.parseInt(part, 10) || 0);
+  const bParts = b.split(".").map((part) => Number.parseInt(part, 10) || 0);
+  for (let i = 0; i < 3; i += 1) {
+    if (aParts[i] !== bParts[i]) return aParts[i] - bParts[i];
+  }
+  return 0;
+}
+
+function pickNewestVersion(...versions) {
+  return versions
+    .map((version) => normalizeVersion(version))
+    .filter((version) => !!version)
+    .reduce(
+      (best, version) => (compareSemver(version, best) > 0 ? version : best),
+      ANTIGRAVITY_FALLBACK_VERSION
+    );
+}
+
+async function fetchJsonWithTimeout(fetchImpl, url) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), ANTIGRAVITY_VERSION_FETCH_TIMEOUT_MS);
+
+  try {
+    const response = await fetchImpl(url, {
+      headers: {
+        Accept: "application/json",
+        "User-Agent": "OmniRoute-AntigravityVersion/1.0",
+      },
+      signal: controller.signal,
+    });
+
+    if (!response.ok) {
+      throw new Error(`Version source ${url} returned ${response.status}`);
+    }
+
+    return response.json();
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+
+function parseOfficialReleaseFeed(payload) {
+  if (!Array.isArray(payload)) return null;
+
+  for (const entry of payload) {
+    const version = normalizeVersion(entry?.version);
+    if (version) return version;
+  }
+
+  return null;
+}
+
+function parseGitHubRelease(payload) {
+  if (!payload || typeof payload !== "object") return null;
+
+  const candidate = payload.tag_name ?? payload.name;
+  return normalizeVersion(candidate);
+}
+
+async function fetchLatestAntigravityVersion(fetchImpl) {
+  const sources = [
+    {
+      parse: parseOfficialReleaseFeed,
+      url: ANTIGRAVITY_RELEASE_FEED_URL,
+    },
+    {
+      parse: parseGitHubRelease,
+      url: ANTIGRAVITY_GITHUB_RELEASE_URL,
+    },
+  ];
+
+  for (const source of sources) {
+    try {
+      const payload = await fetchJsonWithTimeout(fetchImpl, source.url);
+      const version = source.parse(payload);
+      if (version) return version;
+    } catch {
+      // Try next
+    }
+  }
+
+  return null;
+}
+
+export async function resolveAntigravityVersion(fetchImpl = fetch) {
+  const now = Date.now();
+
+  if (versionCache && now - versionCache.fetchedAt < ANTIGRAVITY_VERSION_CACHE_TTL_MS) {
+    return versionCache.version;
+  }
+
+  if (inFlightRequest) {
+    return inFlightRequest;
+  }
+
+  inFlightRequest = (async () => {
+    const resolved = await fetchLatestAntigravityVersion(fetchImpl);
+    const version = resolved
+      ? pickNewestVersion(resolved, ANTIGRAVITY_FALLBACK_VERSION)
+      : pickNewestVersion(versionCache?.version, ANTIGRAVITY_FALLBACK_VERSION);
+
+    if (resolved) {
+      versionCache = {
+        fetchedAt: Date.now(),
+        version,
+      };
+    }
+
+    return version;
+  })();
+
+  try {
+    return await inFlightRequest;
+  } finally {
+    inFlightRequest = null;
+  }
+}
+
+export function getCachedAntigravityVersion() {
+  return versionCache?.version || ANTIGRAVITY_FALLBACK_VERSION;
+}
+
+export function seedAntigravityVersionCache(version, fetchedAt = Date.now()) {
+  versionCache = {
+    fetchedAt,
+    version,
+  };
+}
+
+export function clearAntigravityVersionCache() {
+  versionCache = null;
+  inFlightRequest = null;
+}

package/open-sse/services/clinepassModels.js

@@ -0,0 +1,63 @@
+import { buildClineHeaders } from "../shared/clineAuth.js";
+
+const CLINEPASS_MODELS_ENDPOINT = "https://api.cline.bot/api/v1/models";
+const FETCH_TIMEOUT_MS = 5000;
+
+/**
+ * Build request headers for the ClinePass /models endpoint (Cline's upstream API).
+ * - API keys are sent as plain Bearer tokens.
+ * - OAuth access tokens must carry the WorkOS `workos:` prefix (handled by buildClineHeaders).
+ */
+function buildModelListHeaders(token, isApiKey) {
+  if (isApiKey) {
+    return {
+      Accept: "application/json",
+      Authorization: `Bearer ${token}`,
+    };
+  }
+  return buildClineHeaders(token, { Accept: "application/json" });
+}
+
+/**
+ * Fetch ClinePass live model catalog from Cline's /models endpoint.
+ *
+ * @param {object} credentials - Connection credentials ({ accessToken, apiKey })
+ * @returns {Promise<{ models: { id: string, name: string }[] } | null>}
+ */
+export async function resolveClinepassModels(credentials) {
+  const isApiKey = Boolean(credentials?.apiKey);
+  const token = isApiKey ? credentials.apiKey : credentials?.accessToken;
+  if (!token) return null;
+
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+
+  try {
+    const headers = buildModelListHeaders(token, isApiKey);
+
+    const response = await fetch(CLINEPASS_MODELS_ENDPOINT, {
+      method: "GET",
+      headers,
+      signal: controller.signal,
+    });
+
+    if (!response.ok) return null;
+
+    const json = await response.json();
+    const rawList = Array.isArray(json) ? json : json?.data;
+    if (!Array.isArray(rawList)) return null;
+
+    const models = rawList
+      .filter((m) => typeof m?.id === "string" && m.id.startsWith("cline-pass/"))
+      .map((m) => ({
+        id: m.id,
+        name: m.name || m.id,
+      }));
+
+    return models.length ? { models } : null;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}