ai-cc-router 0.5.1 → 0.5.2

package/dist/proxy/server.js

@@ -83,6 +83,12 @@ export async function startServer(opts = {}) {
         logError(a.id, 0, msg);
         stats.addLog({ ts: Date.now(), accountId: a.id, model: "-", type: "error", details: msg });
     };
+    // Surface rate-limit recovery in the dashboard so users see the account
+    // rejoin the rotation instead of wondering why it stayed red.
+    pool.onCooldownExpired = (a) => {
+        const msg = `${a.id} cooldown expired — rate limit cleared`;
+        stats.addLog({ ts: Date.now(), accountId: a.id, model: "-", type: "route", details: msg });
+    };
     startRefreshLoop(accounts);
     const app = express();
     // ─── Proxy auth middleware ─────────────────────────────────────────────────
@@ -115,6 +121,9 @@ export async function startServer(opts = {}) {
     }
     // ─── Health endpoint (cc-router internal, NOT proxied) ────────────────────
     app.get("/cc-router/health", (_req, res) => {
+        // Sweep expired cooldowns on each poll so the dashboard reflects recovery
+        // even during idle periods when no /v1 request would trigger getNext().
+        pool.sweepExpiredCooldowns();
         res.json({
             status: pool.getHealthy().length > 0 ? "ok" : "degraded",
             mode,

package/dist/proxy/token-pool.js

@@ -12,6 +12,72 @@ function earliestReset(a) {
         return Math.min(r.fiveHourReset, r.sevenDayReset);
     return r.fiveHourReset || r.sevenDayReset || Infinity;
 }
+/**
+ * Returns the reset timestamp (seconds) that must pass before the account
+ * stops being rate_limited. Prefers the `claim` window (the one Anthropic
+ * said was actually limiting); falls back to the earliest non-zero reset.
+ * Returns 0 when no reset is known.
+ */
+function limitingReset(a) {
+    const r = a.rateLimits;
+    if (r.claim === "five_hour" && r.fiveHourReset)
+        return r.fiveHourReset;
+    if (r.claim === "seven_day" && r.sevenDayReset)
+        return r.sevenDayReset;
+    const earliest = earliestReset(a);
+    return Number.isFinite(earliest) ? earliest : 0;
+}
+/**
+ * Roll over any rate-limit window whose reset timestamp has passed.
+ *
+ * `rateLimits` is a snapshot of Anthropic's response headers — utilization
+ * values only refresh when a new response arrives. That creates a stuck
+ * state in two scenarios:
+ *
+ *   1. `status: "rate_limited"` — the pool refuses to route to the account,
+ *      so no new response ever updates the status.
+ *   2. `fiveHourUtil` / `sevenDayUtil` at or above the user cap — `overUserCap`
+ *      evicts the account from rotation, so the util stays stale at its last
+ *      recorded value instead of dropping to ~0 when Anthropic's window resets.
+ *
+ * This sweep resolves both: when `now >= reset` for a window, the util is
+ * zeroed and the window's reset timestamp is cleared. When the limiting
+ * window expires, `status` flips back to `"allowed"`. The callback fires
+ * once per recovery so the dashboard can surface it.
+ */
+function clearExpiredCooldown(a, onExpired) {
+    const nowSec = Math.floor(Date.now() / 1000);
+    const r = a.rateLimits;
+    let changed = false;
+    let recovered = false;
+    if (r.fiveHourReset > 0 && nowSec >= r.fiveHourReset) {
+        r.fiveHourUtil = 0;
+        r.fiveHourReset = 0;
+        changed = true;
+    }
+    if (r.sevenDayReset > 0 && nowSec >= r.sevenDayReset) {
+        r.sevenDayUtil = 0;
+        r.sevenDayReset = 0;
+        changed = true;
+    }
+    // If the account was rate_limited and its claimed window just reset,
+    // return it to rotation. If we can't tell which window was limiting
+    // (empty claim) but all known windows have rolled over, clear the flag.
+    if (r.status === "rate_limited") {
+        const stillBlocked = (r.claim === "five_hour" && r.fiveHourReset > 0) ||
+            (r.claim === "seven_day" && r.sevenDayReset > 0) ||
+            (r.claim === "" && (r.fiveHourReset > 0 || r.sevenDayReset > 0));
+        if (!stillBlocked) {
+            r.status = "allowed";
+            recovered = true;
+            changed = true;
+        }
+    }
+    if (changed)
+        r.lastUpdated = Date.now();
+    if (recovered && onExpired)
+        onExpired(a);
+}
 /** True when the account's user-defined caps have been reached. */
 function overUserCap(a) {
     return (a.rateLimits.fiveHourUtil * 100 >= a.sessionLimitPercent ||
@@ -52,6 +118,10 @@ export class TokenPool {
         if (this.accounts.length === 0) {
             throw new EmptyPoolError("token pool is empty — add an account first");
         }
+        // Sweep expired cooldowns before filtering — otherwise rate_limited accounts
+        // whose reset window has passed would never re-enter rotation.
+        for (const a of this.accounts)
+            clearExpiredCooldown(a, this.onCooldownExpired);
         const available = this.accounts.filter(a => a.healthy &&
             !a.busy &&
             a.rateLimits.status !== "rate_limited" &&
@@ -84,6 +154,18 @@ export class TokenPool {
     /** Optional listener fired when a request is routed to a capped account
      *  because every account in the pool was over its user-configured cap. */
     onCapBypass;
+    /** Optional listener fired when a rate-limited account's cooldown expires
+     *  and it is automatically returned to the rotation. */
+    onCooldownExpired;
+    /**
+     * Sweep the pool for accounts whose rate_limited cooldown has passed and
+     * clear the flag in place. Intended for periodic calls from the dashboard
+     * poll loop so the UI reflects recovery without waiting for a new request.
+     */
+    sweepExpiredCooldowns() {
+        for (const a of this.accounts)
+            clearExpiredCooldown(a, this.onCooldownExpired);
+    }
     getAll() {
         return this.accounts;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-cc-router",
-  "version": "0.5.1",
+  "version": "0.5.2",
   "description": "Round-robin proxy for Claude Max OAuth tokens — use multiple Claude Max accounts with Claude Code",
   "type": "module",
   "bin": {