@timo972/cc-router 0.7.0

package/dist/proxy/token-refresher.js

@@ -0,0 +1,209 @@
+import { writeAnthropicAccountsPreservingOtherProviders, serialize } from "../config/manager.js";
+import { logRefresh } from "./logger.js";
+import { stats } from "./stats.js";
+/**
+ * Official Claude Code CLI client_id for the OAuth PKCE flow.
+ * Source: extracted from Claude Code auth flow.
+ * Update this if Anthropic changes it in a future Claude Code version.
+ */
+const CLAUDE_CODE_CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
+/**
+ * Primary OAuth token endpoint.
+ * Alternative: https://claude.ai/v1/oauth/token
+ */
+const TOKEN_ENDPOINT = "https://claude.ai/v1/oauth/token";
+/** Refresh 10 minutes before expiry */
+const REFRESH_BUFFER_MS = 10 * 60 * 1000;
+/** Check every 5 minutes */
+const CHECK_INTERVAL_MS = 5 * 60 * 1000;
+/** Exact-object locks prevent stale account incarnations from sharing work. */
+const rawRefreshLocks = new Map();
+const ownedRefreshLocks = new Map();
+/** A count is required because concurrent deletion attempts may reserve the same object. */
+const deletionReservations = new Map();
+/** Rotated credentials that still need to be durably written must not rotate again. */
+const pendingDurability = new WeakSet();
+function isReservedForDeletion(account) {
+    return (deletionReservations.get(account) ?? 0) > 0;
+}
+export function needsRefresh(account) {
+    return ownedRefreshLocks.has(account) ||
+        pendingDurability.has(account) ||
+        (account.tokens.expiresAt - Date.now()) < REFRESH_BUFFER_MS;
+}
+export async function refreshAccountToken(account) {
+    // A deletion reservation rejects every new caller, including callers that
+    // would otherwise attach themselves to already-running raw refresh work.
+    if (isReservedForDeletion(account))
+        return false;
+    // Deduplicate concurrent refresh calls for the same account
+    const existing = rawRefreshLocks.get(account);
+    if (existing)
+        return existing;
+    const promise = _doRefresh(account);
+    rawRefreshLocks.set(account, promise);
+    try {
+        return await promise;
+    }
+    finally {
+        if (rawRefreshLocks.get(account) === promise)
+            rawRefreshLocks.delete(account);
+    }
+}
+/** Wait for refresh work owned by this exact account incarnation, if any. */
+export async function waitForAccountRefresh(account) {
+    const activeRefresh = rawRefreshLocks.get(account);
+    const activeOwnedRefresh = ownedRefreshLocks.get(account);
+    await Promise.allSettled([activeRefresh, activeOwnedRefresh].filter((promise) => promise !== undefined));
+}
+/**
+ * Prevent new refreshes for an exact account object and wait for all work that
+ * started before the reservation, including owned persistence, to settle.
+ */
+export async function reserveAccountForDeletion(account) {
+    deletionReservations.set(account, (deletionReservations.get(account) ?? 0) + 1);
+    let released = false;
+    const release = () => {
+        if (released)
+            return;
+        released = true;
+        const remaining = (deletionReservations.get(account) ?? 1) - 1;
+        if (remaining > 0)
+            deletionReservations.set(account, remaining);
+        else
+            deletionReservations.delete(account);
+    };
+    try {
+        await waitForAccountRefresh(account);
+        return release;
+    }
+    catch (error) {
+        release();
+        throw error;
+    }
+}
+async function performOwnedRefresh(account, pool, options) {
+    if (pool.findById(account.id) !== account)
+        return false;
+    if (pendingDurability.has(account)) {
+        (options.persist ?? saveAccounts)(pool.getAll());
+        pendingDurability.delete(account);
+        return true;
+    }
+    const ok = await (options.refresh ?? refreshAccountToken)(account);
+    if (!ok || pool.findById(account.id) !== account)
+        return false;
+    try {
+        (options.persist ?? saveAccounts)(pool.getAll());
+    }
+    catch (error) {
+        pendingDurability.add(account);
+        throw error;
+    }
+    pendingDurability.delete(account);
+    return true;
+}
+/**
+ * Refresh and persist only while the pool still owns this exact object.
+ * Production callers for the same object coalesce through persistence.
+ */
+export function refreshAccountIfCurrent(account, pool, options = {}) {
+    if (isReservedForDeletion(account))
+        return Promise.resolve(false);
+    const existing = ownedRefreshLocks.get(account);
+    if (existing)
+        return existing;
+    let operation;
+    operation = (async () => {
+        try {
+            return await performOwnedRefresh(account, pool, options);
+        }
+        finally {
+            if (ownedRefreshLocks.get(account) === operation) {
+                ownedRefreshLocks.delete(account);
+            }
+        }
+    })();
+    ownedRefreshLocks.set(account, operation);
+    return operation;
+}
+async function _doRefresh(account) {
+    try {
+        const body = new URLSearchParams({
+            grant_type: "refresh_token",
+            refresh_token: account.tokens.refreshToken,
+            client_id: CLAUDE_CODE_CLIENT_ID,
+        });
+        const res = await fetch(TOKEN_ENDPOINT, {
+            method: "POST",
+            headers: { "Content-Type": "application/x-www-form-urlencoded" },
+            body: body.toString(),
+        });
+        if (!res.ok) {
+            const body = await res.text();
+            logRefresh(account.id, false);
+            console.error(`  Status: ${res.status} — ${body}`);
+            account.consecutiveErrors++;
+            account.healthy = false;
+            return false;
+        }
+        const data = await res.json();
+        // CRITICAL: refresh_token ROTATES — save the new one immediately or lose access permanently
+        account.tokens.accessToken = data.access_token;
+        account.tokens.refreshToken = data.refresh_token;
+        account.tokens.expiresAt = Date.now() + data.expires_in * 1000;
+        account.tokens.scopes = data.scope.split(" ");
+        account.healthy = true;
+        account.consecutiveErrors = 0;
+        account.lastRefresh = Date.now();
+        stats.totalRefreshes++;
+        stats.addLog({ ts: Date.now(), accountId: account.id, model: "-", type: "refresh" });
+        const expiresInMin = Math.round(data.expires_in / 60);
+        logRefresh(account.id, true, expiresInMin);
+        return true;
+    }
+    catch (err) {
+        logRefresh(account.id, false);
+        console.error(`  Error:`, err);
+        account.consecutiveErrors++;
+        account.healthy = false;
+        return false;
+    }
+}
+/**
+ * Persist all accounts to disk.
+ * Uses atomic write (tmp + rename) to prevent corruption if process dies mid-write.
+ * Must be called after every successful refresh since refresh_token ROTATES.
+ */
+export function saveAccounts(accounts) {
+    writeAnthropicAccountsPreservingOtherProviders(serialize(accounts));
+}
+/** Run one ownership-aware scheduled refresh pass. */
+export async function refreshAccountsOnce(accounts, options = {}) {
+    const ownershipView = {
+        findById: id => accounts.find(account => account.id === id) ?? null,
+        getAll: () => accounts,
+    };
+    for (const account of [...accounts]) {
+        if (!needsRefresh(account))
+            continue;
+        try {
+            await refreshAccountIfCurrent(account, ownershipView, {
+                persist: options.persist,
+            });
+        }
+        catch (error) {
+            (options.onError ?? console.error)(error);
+        }
+    }
+}
+/**
+ * Background refresh loop: checks every 5 minutes and refreshes any
+ * token expiring within the REFRESH_BUFFER_MS window.
+ */
+export function startRefreshLoop(accounts) {
+    const check = () => refreshAccountsOnce(accounts);
+    // Run immediately on startup (catches already-expired tokens)
+    check().catch(console.error);
+    setInterval(() => { check().catch(console.error); }, CHECK_INTERVAL_MS);
+}

package/dist/proxy/types.js

@@ -0,0 +1,29 @@
+export const DEFAULT_RATE_LIMITS = {
+    status: "unknown",
+    fiveHourUtil: 0,
+    fiveHourReset: 0,
+    sevenDayUtil: 0,
+    sevenDayReset: 0,
+    claim: "",
+    plan: "",
+    requestsLimit: 0,
+    lastUpdated: 0,
+};
+/**
+ * Single source of truth for the default values of user-controllable
+ * account fields. Used by deserialize(), TokenPool.addAccount(),
+ * setupSingleAccount(), and the PATCH validation path.
+ */
+export const ACCOUNT_USER_DEFAULTS = {
+    enabled: true,
+    sessionLimitPercent: 100,
+    weeklyLimitPercent: 100,
+};
+/**
+ * Coerce any unknown value into a valid percent in [0, 100].
+ * Non-numbers, NaN, and out-of-range values collapse to the fallback (100).
+ */
+export function clampPercent(n) {
+    const v = typeof n === "number" && Number.isFinite(n) ? n : 100;
+    return Math.max(0, Math.min(100, Math.round(v)));
+}