zevairouter 1.0.12 → 1.0.14

package/open-sse/services/usage.js

@@ -31,7 +31,16 @@ const MINIMAX_USAGE_URLS = {
 
 // Antigravity API config (from Quotio)
 const ANTIGRAVITY_CONFIG = {
-  quotaApiUrl: "https://cloudcode-pa.googleapis.com/v1internal:fetchAvailableModels",
+  // Multiple upstream domains — Google routes free/paid accounts differently and
+  // some hosts 403 where others 200. Try in order until one answers (ported from
+  // OmniRoute antigravityUpstream.ts).
+  quotaApiHosts: [
+    "https://daily-cloudcode-pa.googleapis.com",
+    "https://cloudcode-pa.googleapis.com",
+    "https://daily-cloudcode-pa.sandbox.googleapis.com",
+  ],
+  fetchAvailableModelsPath: "/v1internal:fetchAvailableModels",
+  retrieveUserQuotaPath: "/v1internal:retrieveUserQuota",
   loadProjectApiUrl: "https://cloudcode-pa.googleapis.com/v1internal:loadCodeAssist",
   tokenUrl: "https://oauth2.googleapis.com/token",
   clientId: "1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com",
@@ -94,7 +103,7 @@ export async function getUsageForProvider(connection, proxyOptions = null) {
     case "gemini-cli":
       return await getGeminiUsage(accessToken, providerDataWithProjectId, proxyOptions);
     case "antigravity":
-      return await getAntigravityUsage(accessToken, providerSpecificData, proxyOptions);
+      return await getAntigravityUsage(accessToken, providerDataWithProjectId, proxyOptions);
     case "claude":
       return await getClaudeUsage(accessToken, proxyOptions);
     case "codex":
@@ -659,51 +668,88 @@ async function getGeminiSubscriptionInfo(accessToken, proxyOptions = null) {
 }
 
 /**
- * Antigravity Usage - Fetch quota from Google Cloud Code API
+ * POST to the first Antigravity host that answers (2xx/401/403). Returns
+ * { response, host } or throws if every host is unreachable.
  */
-async function getAntigravityUsage(accessToken, providerSpecificData, proxyOptions = null) {
-  try {
-    // Fetch subscription info once \u2014 reuse for both projectId and plan
-    const subscriptionInfo = await getAntigravitySubscriptionInfo(accessToken, proxyOptions);
-    const projectId = subscriptionInfo?.cloudaicompanionProject || null;
-
-    // Fetch quota data with timeout
+async function antigravityQuotaFetch(path, accessToken, bodyObj, proxyOptions) {
+  let lastError = null;
+  for (const host of ANTIGRAVITY_CONFIG.quotaApiHosts) {
     const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), 10000); // 10s timeout
-
-    let response;
+    const timeoutId = setTimeout(() => controller.abort(), 10000);
     try {
-      response = await proxyAwareFetch(ANTIGRAVITY_CONFIG.quotaApiUrl, {
+      const response = await proxyAwareFetch(`${host}${path}`, {
         method: "POST",
         headers: {
           "Authorization": `Bearer ${accessToken}`,
           "User-Agent": ANTIGRAVITY_CONFIG.userAgent,
           "Content-Type": "application/json",
-          "X-Client-Name": "antigravity",
-          "X-Client-Version": "1.107.0",
           "x-request-source": "local", // MITM bypass
         },
-        body: JSON.stringify({
-          ...(projectId ? { project: projectId } : {})
-        }),
+        body: JSON.stringify(bodyObj || {}),
         signal: controller.signal,
       }, proxyOptions);
+      // A definitive answer (ok, or auth/permission verdict) ends the loop; only
+      // transient upstream errors (5xx / network) fall through to the next host.
+      if (response.ok || response.status === 401 || response.status === 403) {
+        return { response, host };
+      }
+      lastError = new Error(`Antigravity API error: ${response.status}`);
+    } catch (error) {
+      lastError = error;
     } finally {
       clearTimeout(timeoutId);
     }
+  }
+  if (lastError) throw lastError;
+  throw new Error("Antigravity API unavailable");
+}
 
-    if (response.status === 403) {
-      return {
-        message: "Antigravity quota API access forbidden. Chat may still work.",
-        quotas: {}
-      };
+/**
+ * Antigravity Usage - Fetch quota from Google Cloud Code API.
+ *
+ * Two upstream sources are merged:
+ *   - fetchAvailableModels: catalog + per-model quotaInfo (can be stale/full).
+ *   - retrieveUserQuota:    per-model consumption buckets (source of truth).
+ * retrieveUserQuota wins when it reports a model, matching OmniRoute behaviour.
+ */
+async function getAntigravityUsage(accessToken, providerSpecificData, proxyOptions = null) {
+  try {
+    // Prefer the projectId stored on the connection; fall back to loadCodeAssist.
+    const savedProjectId = normalizeCloudCodeProjectId(providerSpecificData?.projectId);
+    let subscriptionInfo = null;
+    let projectId = savedProjectId;
+    if (!projectId) {
+      subscriptionInfo = await getAntigravitySubscriptionInfo(accessToken, proxyOptions);
+      projectId = normalizeCloudCodeProjectId(subscriptionInfo?.cloudaicompanionProject);
+    }
+
+    // fetchAvailableModels (catalog) \u2014 required. retrieveUserQuota (live) \u2014 best effort.
+    let modelsResp;
+    try {
+      modelsResp = await antigravityQuotaFetch(
+        ANTIGRAVITY_CONFIG.fetchAvailableModelsPath,
+        accessToken,
+        projectId ? { project: projectId } : {},
+        proxyOptions
+      );
+    } catch (error) {
+      return { message: `Antigravity quota unavailable: ${error.message}. Chat may still work.` };
     }
 
+    const response = modelsResp.response;
+
     if (response.status === 401) {
-      return {
-        message: "Antigravity quota API authentication expired. Chat may still work.",
-        quotas: {}
-      };
+      // Distinguish a dead account (refresh token revoked/deleted) from a merely
+      // stale access token, so the dashboard can tell the user which is which.
+      const deadReason = await getAntigravityAccountDeadReason(providerSpecificData, proxyOptions);
+      if (deadReason) {
+        return { accountDead: true, message: `Antigravity account ${deadReason}. Reconnect won't help \u2014 recreate the account.`, quotas: {} };
+      }
+      return { message: "Antigravity quota API authentication expired. Chat may still work.", quotas: {} };
+    }
+
+    if (response.status === 403) {
+      return { message: "Antigravity quota API access forbidden (tier may not expose quota). Chat may still work.", quotas: {} };
     }
 
     if (!response.ok) {
@@ -711,11 +757,33 @@ async function getAntigravityUsage(accessToken, providerSpecificData, proxyOptio
     }
 
     const data = await response.json();
-    const quotas = {};
 
-    // Parse model quotas (inspired by vscode-antigravity-cockpit)
+    // Live consumption buckets keyed by modelId (source of truth).
+    // retrieveUserQuota works with or without a project — send the project when
+    // we have one, otherwise an empty body (Google resolves the default project).
+    const liveBuckets = new Map();
+    try {
+      const quotaResp = await antigravityQuotaFetch(
+        ANTIGRAVITY_CONFIG.retrieveUserQuotaPath,
+        accessToken,
+        projectId ? { project: projectId } : {},
+        proxyOptions
+      );
+      if (quotaResp.response.ok) {
+        const quotaData = await quotaResp.response.json();
+        if (Array.isArray(quotaData.buckets)) {
+          for (const bucket of quotaData.buckets) {
+            const id = String(bucket.modelId || "").trim();
+            if (id) liveBuckets.set(id, bucket);
+          }
+        }
+      }
+    } catch {
+      // Non-fatal: fall back to catalog-only quotaInfo.
+    }
+
+    const quotas = {};
     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',
@@ -729,32 +797,27 @@ async function getAntigravityUsage(accessToken, providerSpecificData, proxyOptio
       ];
 
       for (const [modelKey, info] of Object.entries(data.models)) {
-        // Skip models without quota info
-        if (!info.quotaInfo) {
-          continue;
-        }
+        if (info.isInternal || !importantModels.includes(modelKey)) continue;
 
-        // Skip internal models and non-important models
-        if (info.isInternal || !importantModels.includes(modelKey)) {
-          continue;
-        }
+        // retrieveUserQuota bucket wins over the (possibly stale) catalog quotaInfo.
+        const live = liveBuckets.get(modelKey);
+        const quotaSource = live || info.quotaInfo;
+        if (!quotaSource) continue;
 
-        const remainingFraction = info.quotaInfo.remainingFraction || 0;
+        const remainingFraction = Number(quotaSource.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;
+        const used = Math.max(0, total - remaining);
 
-        // Use modelKey as key (matches PROVIDER_MODELS id)
         quotas[modelKey] = {
           used,
           total,
-          resetAt: parseResetTime(info.quotaInfo.resetTime),
+          resetAt: parseResetTime(quotaSource.resetTime),
           remainingPercentage,
           unlimited: false,
           displayName: info.displayName || modelKey,
+          quotaSource: live ? "retrieveUserQuota" : "fetchAvailableModels",
         };
       }
     }
@@ -770,6 +833,48 @@ async function getAntigravityUsage(accessToken, providerSpecificData, proxyOptio
   }
 }
 
+/**
+ * Probe whether an Antigravity account is permanently dead (refresh token
+ * revoked / account deleted). Returns a short reason string, or null if the
+ * account looks alive (or we can't tell). Used to turn a misleading
+ * "authentication expired" into an actionable "account deleted" verdict.
+ */
+async function getAntigravityAccountDeadReason(providerSpecificData, proxyOptions = null) {
+  const refreshToken = providerSpecificData?.refreshToken;
+  if (!refreshToken) return null;
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 10000);
+    let response;
+    try {
+      response = await proxyAwareFetch(ANTIGRAVITY_CONFIG.tokenUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams({
+          client_id: ANTIGRAVITY_CONFIG.clientId,
+          client_secret: ANTIGRAVITY_CONFIG.clientSecret,
+          refresh_token: refreshToken,
+          grant_type: "refresh_token",
+        }),
+        signal: controller.signal,
+      }, proxyOptions);
+    } finally {
+      clearTimeout(timeoutId);
+    }
+    if (response.ok) return null; // refresh works \u2192 account alive, token just stale
+    const body = await response.json().catch(() => ({}));
+    if (body.error === "invalid_grant") {
+      const desc = (body.error_description || "").toLowerCase();
+      if (desc.includes("deleted")) return "has been deleted";
+      if (desc.includes("disabled") || desc.includes("suspend")) return "is disabled/suspended";
+      return "authorization was revoked";
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Get Antigravity project ID from subscription info
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zevairouter",
-  "version": "1.0.12",
+  "version": "1.0.14",
   "description": "ZevaiRouter - AI Router with provider automation, multi-account workflows, and quota tracking",
   "bin": {
     "zevai": "./cli/cli.js"
@@ -62,7 +62,7 @@
     "socks-proxy-agent": "^10.1.0",
     "sql.js": "^1.14.1",
     "undici": "^8.4.1",
-    "uuid": "^13.0.0",
+    "uuid": "^14.0.1",
     "zustand": "^5.0.10"
   },
   "optionalDependencies": {
@@ -74,7 +74,7 @@
   "comment_camoufox_js": "optional stealth-Firefox engine for bulk-import; runtime auto-installs to user data dir if user picks Camoufox in the modal but the package is missing — Chromium remains the default and works without this dep",
   "devDependencies": {
     "@tailwindcss/postcss": "^4.1.18",
-    "esbuild": "^0.25.12",
+    "esbuild": "^0.28.1",
     "eslint": "^9",
     "eslint-config-next": "16.2.9",
     "postcss": "^8.5.6",

package/src/app/(dashboard)/dashboard/profile/page.js

@@ -946,6 +946,21 @@ export default function ProfilePage() {
               </div>
             )}
 
+            {/* Most Quota (smart routing) */}
+            <div className="flex items-start sm:items-center justify-between gap-4 pt-4 border-t border-border/50">
+              <div className="flex-1 min-w-0">
+                <p className="font-medium text-sm sm:text-base">Most Quota</p>
+                <p className="text-xs sm:text-sm text-text-muted">
+                  Pick the account with the most remaining quota (uses cached usage)
+                </p>
+              </div>
+              <Toggle
+                checked={settings.fallbackStrategy === "most-quota"}
+                onChange={() => updateFallbackStrategy(settings.fallbackStrategy === "most-quota" ? "fill-first" : "most-quota")}
+                disabled={loading}
+              />
+            </div>
+
             {/* Combo Round Robin */}
             <div className="flex items-start sm:items-center justify-between gap-4 pt-4 border-t border-border/50">
               <div className="flex-1 min-w-0">

package/src/app/(dashboard)/dashboard/usage/components/ProviderLimits/index.js

@@ -403,7 +403,7 @@ export default function ProviderLimits() {
   );
 
   // Fetch quota for a specific connection
-  const fetchQuota = useCallback(async (connectionId, provider) => {
+  const fetchQuota = useCallback(async (connectionId, provider, force = false) => {
     setLoading((prev) => ({ ...prev, [connectionId]: true }));
     setErrors((prev) => ({ ...prev, [connectionId]: null }));
 
@@ -411,7 +411,7 @@ export default function ProviderLimits() {
       console.log(
         `[ProviderLimits] Fetching quota for ${provider} (${connectionId})`,
       );
-      const response = await fetch(`/api/usage/${connectionId}`);
+      const response = await fetch(`/api/usage/${connectionId}${force ? "?refresh=1" : ""}`);
 
       if (!response.ok) {
         const errorData = await response.json().catch(() => ({}));
@@ -636,7 +636,7 @@ export default function ProviderLimits() {
       );
 
       await Promise.all(
-        visibleConnections.map((conn) => fetchQuota(conn.id, conn.provider)),
+        visibleConnections.map((conn) => fetchQuota(conn.id, conn.provider, true)),
       );
 
       setLastUpdated(new Date());

package/src/app/api/init/route.js

@@ -1,4 +1,12 @@
 // This API route is called automatically to initialize app
+import { startQuotaRefreshLoop } from "@/lib/usage/quotaRefresh";
+
 export async function GET() {
+  // Start the background quota-refresh loop (guarded so it only starts once).
+  try {
+    startQuotaRefreshLoop();
+  } catch (e) {
+    console.warn(`[Init] quota refresh loop start failed: ${e.message}`);
+  }
   return new Response("Initialized", { status: 200 });
 }

package/src/app/api/oauth/antigravity/bulk-import/route.js

@@ -31,6 +31,8 @@ export async function POST(request) {
       accounts,
       concurrency: body?.concurrency,
       engine: body?.engine,
+      proxyPoolMode: body?.proxyPoolMode,
+      proxyPoolId: body?.proxyPoolId,
     });
 
     return NextResponse.json({

package/src/app/api/usage/[connectionId]/route.js

@@ -1,188 +1,40 @@
 // Ensure proxyFetch is loaded to patch globalThis.fetch
 import "open-sse/index.js";
 
-import { getProviderConnectionById, updateProviderConnection } from "@/lib/localDb";
-import { getUsageForProvider } from "open-sse/services/usage.js";
-import { getExecutor } from "open-sse/executors/index.js";
-import { resolveConnectionProxyConfig } from "@/lib/network/connectionProxy";
-import { USAGE_APIKEY_PROVIDERS } from "@/shared/constants/providers";
+import { getQuotaSnapshot } from "@/lib/localDb";
+import { resolveUsageForConnection } from "@/lib/usage/quotaService";
 
-// Detect auth-expired messages returned by usage providers instead of throwing
-const AUTH_EXPIRED_PATTERNS = ["expired", "authentication", "unauthorized", "401", "re-authorize"];
-function isAuthExpiredMessage(usage) {
-  if (!usage?.message) return false;
-  const msg = usage.message.toLowerCase();
-  return AUTH_EXPIRED_PATTERNS.some((p) => msg.includes(p));
-}
-
-/**
- * Refresh credentials using executor and update database
- * @param {boolean} force - Skip needsRefresh check and always attempt refresh
- * @returns Promise<{ connection, refreshed: boolean }>
- */
-async function refreshAndUpdateCredentials(connection, force = false, proxyOptions = null) {
-  const executor = getExecutor(connection.provider);
-
-  // Build credentials object from connection
-  const credentials = {
-    accessToken: connection.accessToken,
-    refreshToken: connection.refreshToken,
-    idToken: connection.idToken,
-    expiresAt: connection.expiresAt || connection.tokenExpiresAt,
-    lastRefreshAt: connection.lastRefreshAt,
-    connectionId: connection.id,
-    providerSpecificData: connection.providerSpecificData,
-    // For GitHub
-    copilotToken: connection.providerSpecificData?.copilotToken,
-    copilotTokenExpiresAt: connection.providerSpecificData?.copilotTokenExpiresAt,
-  };
-
-  // Check if refresh is needed (skip when force=true)
-  const needsRefresh = force || executor.needsRefresh(credentials);
-
-  if (!needsRefresh) {
-    return { connection, refreshed: false };
-  }
-
-  // Use executor's refreshCredentials method (with optional proxy)
-  const refreshResult = await executor.refreshCredentials(credentials, console, proxyOptions);
-
-  if (!refreshResult) {
-    // Refresh failed but we still have an accessToken — try with existing token
-    if (connection.accessToken) {
-      return { connection, refreshed: false };
-    }
-    throw new Error("Failed to refresh credentials. Please re-authorize the connection.");
-  }
-
-  // Build update object
-  const now = new Date().toISOString();
-  const updateData = {
-    updatedAt: now,
-  };
-
-  // Update accessToken if present
-  if (refreshResult.accessToken) {
-    updateData.accessToken = refreshResult.accessToken;
-  }
-
-  // Update refreshToken if present
-  if (refreshResult.refreshToken) {
-    updateData.refreshToken = refreshResult.refreshToken;
-  }
-
-  if (refreshResult.idToken) {
-    updateData.idToken = refreshResult.idToken;
-  }
-
-  if (refreshResult.lastRefreshAt) {
-    updateData.lastRefreshAt = refreshResult.lastRefreshAt;
-  }
-
-  // Update token expiry
-  if (refreshResult.expiresIn) {
-    updateData.expiresAt = new Date(Date.now() + refreshResult.expiresIn * 1000).toISOString();
-    updateData.expiresIn = refreshResult.expiresIn;
-  } else if (refreshResult.expiresAt) {
-    updateData.expiresAt = refreshResult.expiresAt;
-  }
-
-  // Handle provider-specific data (copilotToken for GitHub, etc.)
-  const providerSpecificUpdates = {
-    ...(refreshResult.providerSpecificData || {}),
-    ...(refreshResult.copilotToken ? { copilotToken: refreshResult.copilotToken } : {}),
-    ...(refreshResult.copilotTokenExpiresAt ? { copilotTokenExpiresAt: refreshResult.copilotTokenExpiresAt } : {}),
-  };
-  if (Object.keys(providerSpecificUpdates).length > 0) {
-    updateData.providerSpecificData = {
-      ...(connection.providerSpecificData || {}),
-      ...providerSpecificUpdates,
-    };
-  }
-
-  // Update database
-  await updateProviderConnection(connection.id, updateData);
-
-  // Return updated connection
-  const updatedConnection = {
-    ...connection,
-    ...updateData,
-    providerSpecificData: updateData.providerSpecificData || connection.providerSpecificData,
-  };
-
-  return {
-    connection: updatedConnection,
-    refreshed: true,
-  };
-}
+// Serve cached quota when it's fresher than this; otherwise fetch live.
+const CACHE_FRESH_MS = 60 * 1000;
 
 /**
- * GET /api/usage/[connectionId] - Get usage data for a specific connection
+ * GET /api/usage/[connectionId] - Get usage data for a specific connection.
+ *
+ * Reads the server-side quota cache first (instant); only hits the upstream API
+ * when the cache is stale or `?refresh=1` is passed. Live fetches also write the
+ * cache so routing + dashboard stay in sync.
  */
 export async function GET(request, { params }) {
-  let connection;
+  let connectionId;
   try {
-    const { connectionId } = await params;
-
-
-    // Get connection from database
-    connection = await getProviderConnectionById(connectionId);
-    if (!connection) {
-      return Response.json({ error: "Connection not found" }, { status: 404 });
-    }
-
-    // Allow OAuth connections, plus whitelisted apikey providers (glm/minimax/...)
-    const isOAuth = connection.authType === "oauth";
-    const isApikeyEligible =
-      connection.authType === "apikey" &&
-      USAGE_APIKEY_PROVIDERS.includes(connection.provider);
-
-    if (!isOAuth && !isApikeyEligible) {
-      return Response.json({ message: "Usage not available for this connection" });
-    }
-
-    // Resolve connection proxy config; force strictProxy=false so quota/refresh fall back to direct on failure
-    const proxyConfig = await resolveConnectionProxyConfig(connection.providerSpecificData);
-    const proxyOptions = {
-      connectionProxyEnabled: proxyConfig.connectionProxyEnabled === true,
-      connectionProxyUrl: proxyConfig.connectionProxyUrl || "",
-      connectionNoProxy: proxyConfig.connectionNoProxy || "",
-      vercelRelayUrl: proxyConfig.vercelRelayUrl || "",
-      strictProxy: false,
-    };
-
-    // Refresh credentials only for OAuth connections (apikey has no token refresh)
-    if (isOAuth) {
-      try {
-        const result = await refreshAndUpdateCredentials(connection, false, proxyOptions);
-        connection = result.connection;
-      } catch (refreshError) {
-        console.error("[Usage API] Credential refresh failed:", refreshError);
-        return Response.json({
-          error: `Credential refresh failed: ${refreshError.message}`
-        }, { status: 401 });
+    ({ connectionId } = await params);
+    const url = new URL(request.url);
+    const force = url.searchParams.get("refresh") === "1";
+
+    if (!force) {
+      const snap = await getQuotaSnapshot(connectionId);
+      if (snap?.usage && Date.now() - new Date(snap.fetchedAt).getTime() < CACHE_FRESH_MS) {
+        return Response.json({ ...snap.usage, cached: true, fetchedAt: snap.fetchedAt });
       }
     }
 
-    // Fetch usage from provider API
-    let usage = await getUsageForProvider(connection, proxyOptions);
-
-    // If provider returned an auth-expired message instead of throwing,
-    // force-refresh token and retry once (OAuth only)
-    if (isOAuth && isAuthExpiredMessage(usage) && connection.refreshToken) {
-      try {
-        const retryResult = await refreshAndUpdateCredentials(connection, true, proxyOptions);
-        connection = retryResult.connection;
-        usage = await getUsageForProvider(connection, proxyOptions);
-      } catch (retryError) {
-        console.warn(`[Usage] ${connection.provider}: force refresh failed: ${retryError.message}`);
-      }
+    const usage = await resolveUsageForConnection(connectionId, { writeCache: true, force });
+    if (usage?.notFound) {
+      return Response.json({ error: "Connection not found" }, { status: 404 });
     }
-
     return Response.json(usage);
   } catch (error) {
-    const provider = connection?.provider ?? "unknown";
-    console.warn(`[Usage] ${provider}: ${error.message}`);
+    console.warn(`[Usage] ${connectionId || "unknown"}: ${error.message}`);
     return Response.json({ error: error.message }, { status: 500 });
   }
 }

package/src/app/globals.css

@@ -510,11 +510,9 @@ button {
     0 1px 2px rgba(15, 23, 42, 0.05),
     0 10px 24px -10px rgba(15, 23, 42, 0.18),
     0 24px 48px -24px rgba(15, 23, 42, 0.22);
-  transform: perspective(1200px) translateZ(0);
-  transform-style: preserve-3d;
-  transition: transform 0.35s cubic-bezier(0.22, 1, 0.36, 1),
+  transform: translateY(0);
+  transition: transform 0.3s cubic-bezier(0.22, 1, 0.36, 1),
               box-shadow 0.35s cubic-bezier(0.22, 1, 0.36, 1);
-  will-change: transform;
 }
 .card-3d::before {
   content: "";
@@ -527,7 +525,7 @@ button {
 }
 .card-3d > * { position: relative; z-index: 1; }
 .card-3d:hover {
-  transform: perspective(1200px) translateY(-3px) rotateX(1deg) rotateY(-1deg);
+  transform: translateY(-3px);
   box-shadow:
     inset 0 1px 0 0 rgba(255, 255, 255, 0.6),
     0 2px 4px rgba(15, 23, 42, 0.06),
@@ -568,8 +566,8 @@ button {
     0 44px 80px -28px rgba(0, 0, 0, 0.72);
 }
 
-/* Respect reduced-motion: keep depth, drop the tilt/scale animation */
+/* Respect reduced-motion: keep depth, drop the movement */
 @media (prefers-reduced-motion: reduce) {
   .card-3d { transition: box-shadow 0.3s ease; }
-  .card-3d:hover { transform: perspective(1200px) translateY(-2px); }
+  .card-3d:hover { transform: none; }
 }

package/src/lib/db/index.js

@@ -27,6 +27,12 @@ export {
   createProxyPool, updateProxyPool, deleteProxyPool,
 } from "./repos/proxyPoolsRepo.js";
 
+// Quota cache (server-side per-account quota snapshots for routing)
+export {
+  saveQuotaSnapshot, getQuotaSnapshot, getAllQuotaSnapshots,
+  deleteQuotaSnapshot, getCachedRemainingPercent,
+} from "./repos/quotaCacheRepo.js";
+
 // API keys
 export {
   getApiKeys, getApiKeyById, createApiKey, updateApiKey, deleteApiKey, validateApiKey,