ai-cc-router 0.5.0 → 0.5.2

package/dist/cli/cmd-status.js

@@ -70,9 +70,17 @@ async function jsonOutput(port) {
  * Launches the Ink dashboard and handles "re-launch" intents.
  *
  * The dashboard cannot run inquirer prompts while Ink owns stdin, so when
- * the user presses `n` to add an account, Ink unmounts and this loop runs
- * the OAuth flow synchronously. Once tokens are obtained and POSTed to the
+ * the user presses `n` to add an account, Ink unmounts **completely** first.
+ * Only after `waitUntilExit()` resolves — and stdin is restored from raw mode
+ * — does the OAuth flow run. Once tokens are obtained and POSTed to the
  * server, the dashboard is re-rendered and polling resumes.
+ *
+ * IMPORTANT: The previous design resolved the outer promise from inside
+ * `onIntent` (before Ink unmounted), then raced with `waitUntilExit`. That
+ * caused inquirer to see a half-released stdin and force-close itself.
+ * The fix: `onIntent` writes to a mutable variable; `waitUntilExit()`
+ * is the ONLY thing that resolves the await; stdin is explicitly restored
+ * before inquirer runs.
  */
 async function dashboardLoop(port) {
     // Dynamic imports keep these heavy deps out of the cold-start path
@@ -83,23 +91,36 @@ async function dashboardLoop(port) {
     ]);
     while (true) {
         const target = resolveStatusTarget(port);
-        const intent = await new Promise((resolve) => {
-            const onIntent = (i) => resolve(i);
-            const instance = render(createElement(Dashboard, {
-                port,
-                baseUrl: target.baseUrl,
-                authToken: target.authToken,
-                onIntent,
-            }), 
-            // Let Ink handle Ctrl+C — it calls exit() which cleanly unmounts
-            { exitOnCtrlC: true });
-            // If Ink exits on its own (Ctrl+C or `q`) without firing onIntent, treat as quit.
-            instance.waitUntilExit().then(() => resolve("quit"));
-        });
-        if (intent === "quit")
+        // `pendingIntent` is set by the Dashboard component via `onIntent`;
+        // it defaults to "quit" so Ctrl+C (exitOnCtrlC) does the right thing
+        // without the Dashboard ever firing onIntent.
+        let pendingIntent = "quit";
+        const instance = render(createElement(Dashboard, {
+            port,
+            baseUrl: target.baseUrl,
+            authToken: target.authToken,
+            onIntent: (i) => { pendingIntent = i; },
+        }), { exitOnCtrlC: true });
+        // Block until Ink has FULLY unmounted and released stdin.
+        // The Dashboard's keyboard handler calls exit() for both `q` and `n`;
+        // Ctrl+C also triggers exit via exitOnCtrlC.
+        await instance.waitUntilExit();
+        // Yield the event loop so any of Ink's pending stdin cleanup tasks
+        // (listeners detach, raw-mode restore) run before inquirer grabs stdin.
+        // Without this, inquirer can see a half-released stdin and throw
+        // "User force closed the prompt".
+        await new Promise(resolve => setImmediate(resolve));
+        // Ink leaves stdin in raw mode. Restore it before running inquirer or
+        // exiting, otherwise the terminal may remain in a broken state.
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(false);
+        }
+        // Ink may have paused stdin — resume it so inquirer can read input.
+        process.stdin.resume();
+        if (pendingIntent === "quit")
             return;
-        // Intent: addAccount — unmount and run the OAuth flow, then POST the
-        // resulting tokens to the server we're connected to (local or remote).
+        // Intent: addAccount — run the OAuth flow, then POST the resulting
+        // tokens to the server we're connected to (local or remote).
         console.log();
         console.log(chalk.cyan("→ Adding a new account..."));
         console.log();

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/dist/ui/Dashboard.js

@@ -202,8 +202,11 @@ function LiveDashboard({ data, port, lastUpdate, api, onIntent, }) {
             return;
         }
         // ── Normal view mode ────────────────────────────────────────────────
+        // Always call exit() so Ink fully unmounts and releases stdin.
+        // The outer dashboardLoop reads `pendingIntent` after waitUntilExit().
         if (input === "q") {
-            onIntent ? onIntent("quit") : exit();
+            onIntent?.("quit");
+            exit();
             return;
         }
         if (key.escape) {
@@ -211,7 +214,8 @@ function LiveDashboard({ data, port, lastUpdate, api, onIntent, }) {
                 setFocus("logs");
                 return;
             }
-            onIntent ? onIntent("quit") : exit();
+            onIntent?.("quit");
+            exit();
             return;
         }
         if (key.tab) {
@@ -258,7 +262,9 @@ function LiveDashboard({ data, port, lastUpdate, api, onIntent, }) {
                 return;
             }
         }
-        // n = add account — works regardless of focus
+        // n = add account — works regardless of focus.
+        // Requires an onIntent handler because the outer loop runs the OAuth
+        // flow after Ink unmounts; if none is wired, this key is a no-op.
         if (input === "n") {
             if (onIntent) {
                 onIntent("addAccount");

package/package.json

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