@timo972/cc-router 0.10.0-rc.3 → 0.10.0-rc.5

package/CHANGELOG.md

@@ -10,6 +10,19 @@ This project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ### Added
 
+- OpenAI/Codex account usage is fetched proactively, so `cc-router status`
+  shows the 5h/weekly bars immediately after a restart — matching how
+  Anthropic accounts already behaved. Codex usage previously arrived only on
+  `x-codex-*` response headers, so a freshly restarted daemon rendered empty
+  OpenAI bars until the first request happened to route there. The daemon now
+  polls the usage endpoint the Codex CLI itself reads
+  (`GET chatgpt.com/backend-api/wham/usage`) on the same bounded scheduler the
+  Anthropic usage refresher uses (staggered startup, 5-minute cadence, failure
+  backoff, identity-owned application), feeding the JSON — the payload twin of
+  the response headers, parsed under the same trust rules — through the exact
+  merge the headers go through. A failed poll keeps whatever the account
+  already knew; an expired access token is refreshed before the first fetch
+  rather than 401-ing until traffic happens to fix it.
 - `cc-router accounts rename <id> <new-id>`. An account's id is the key its
   routing state hangs off — in-flight counters and sticky session bindings are
   both id-keyed — so on a running proxy the rename runs as a transaction
@@ -42,6 +55,34 @@ This project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ### Fixed
 
+- Anthropic activity rows show their cache rate and token counts. The proxy
+  captures usage by passively parsing the response body, but skipped any
+  compressed response — and since the proxy is byte-transparent, the client's
+  own `accept-encoding` makes upstream compress essentially every response, so
+  no `/messages` row ever carried token fields while Codex rows (whose relay
+  decompresses anyway) did. The capture now decompresses its own copy of the
+  stream (gzip/brotli/deflate) purely for parsing, stops paying for the
+  stream once both usage events have been seen, and remains strictly
+  best-effort: a corrupt or unsupported coding ends the capture, never the
+  response.
+- `cc-router stop` no longer terminates itself — or your editor sessions —
+  when it falls back to killing by port. The fallback listed every process
+  with a socket on the proxy port (`lsof -ti :port` reports both ends of
+  every connection), which included the stop CLI itself (its health-check
+  fetch leaves a keep-alive socket open) and any live Claude Code or Codex
+  session talking to the proxy. All of them received SIGTERM alongside the
+  daemon; the shell reported the stop command as `zsh: terminated`. The
+  listing now selects only the process LISTENING on the port, and killing by
+  port additionally never targets the process doing the killing.
+- Service-mode `cc-router start` no longer reports "nothing is answering" for
+  a service that comes up moments later. The post-bootstrap health wait was
+  10 seconds, but a stop→start restart re-bootstraps a label whose process
+  exited moments earlier, and launchd throttles that spawn by up to ~10s
+  (default ThrottleInterval) before the daemon even begins booting — so the
+  window regularly closed right as throttled spawns landed, and the very
+  next `cc-router status` connected fine. The wait now outlasts the throttle
+  (30s), says what it is waiting for, and a genuine timeout points to
+  `cc-router status` before suggesting the logs.
 - OpenAI activity rows carry the same columns as Claude ones. The OpenAI ingress
   recorded a path but no method and no client, and the dashboard needs both
   `method` and `path` to render the request — so those rows fell back to the

package/dist/cli/cmd-start.js

@@ -7,6 +7,16 @@ import { checkForUpdate, performUpdate, PKG_NAME } from "../utils/self-update.js
 import { launchDaemon, waitForHealth } from "../daemon/launcher.js";
 import { installService } from "../daemon/service.js";
 import { getLocalIPs } from "../utils/network.js";
+/**
+ * How long service-mode start waits for the proxy to answer after the
+ * LaunchAgent/systemd unit is loaded. This must outlast more than daemon
+ * startup: a stop→start restart re-bootstraps a label whose process exited
+ * moments earlier, and launchd throttles that spawn by up to ~10s (default
+ * ThrottleInterval) before the daemon even begins booting. The previous 10s
+ * budget ended right as throttled spawns typically landed, reporting
+ * "nothing answering" for a service that came up seconds later.
+ */
+export const SERVICE_HEALTH_TIMEOUT_MS = 30_000;
 export function registerStart(program) {
     program
         .command("start")
@@ -82,13 +92,14 @@ export function registerStart(program) {
             // Installing the service is not the same as the proxy being up: if
             // launchd rejects the load, `installService` only warns. Verify, so a
             // failed start is not reported as a success.
-            if (await waitForHealth(port, 10_000)) {
+            console.log(chalk.gray(`  Waiting for the proxy on port ${port} (a quick restart can be throttled by the service manager)...`));
+            if (await waitForHealth(port, SERVICE_HEALTH_TIMEOUT_MS)) {
                 console.log(chalk.green(`✓ CC-Router running on port ${port}`));
             }
             else {
-                console.log(chalk.yellow(`\n⚠ Service configured, but nothing is answering on port ${port}.`));
-                console.log(chalk.gray(`  Check the logs: cc-router logs`));
-                console.log(chalk.gray(`  Then try again: cc-router start`));
+                console.log(chalk.yellow(`\n⚠ Service configured, but nothing answered on port ${port} within ${Math.round(SERVICE_HEALTH_TIMEOUT_MS / 1000)}s.`));
+                console.log(chalk.gray(`  It may still come up — check: cc-router status`));
+                console.log(chalk.gray(`  If it does not: cc-router logs, then try again: cc-router start`));
                 process.exitCode = 1;
                 return;
             }

package/dist/daemon/launcher.js

@@ -158,32 +158,47 @@ export async function killPortAndWait(port, deps, timeoutMs = 5_000) {
 }
 const DEATH_POLL_MS = 200;
 const POST_KILL_GRACE_MS = 500;
-async function killByPort(port) {
+/**
+ * PIDs that should die when the proxy on `port` is killed by port: the
+ * process LISTENING on it — never connected clients. A bare `lsof -ti :port`
+ * lists BOTH ends of every connection, which included the stop CLI itself
+ * (its health-check fetch leaves a keep-alive socket open) and any live
+ * Claude Code / Codex session talking to the proxy; `cc-router stop` then
+ * SIGTERMed all of them, itself included (`zsh: terminated`).
+ */
+export async function listListeningPids(port) {
     const { execFile } = await import("child_process");
     const { promisify } = await import("util");
     const execFileAsync = promisify(execFile);
-    const listPids = async (p) => {
-        try {
-            if (isWindows()) {
-                const { stdout } = await execFileAsync("netstat", ["-ano"]);
-                const match = stdout
-                    .split("\n")
-                    .find(line => line.includes(`:${p}`) && line.includes("LISTENING"));
-                if (!match)
-                    return [];
-                const pid = Number(match.trim().split(/\s+/).at(-1));
-                return Number.isNaN(pid) ? [] : [pid];
-            }
-            const { stdout } = await execFileAsync("lsof", ["-ti", `:${p}`]);
-            return stdout.trim().split("\n").filter(Boolean).map(Number).filter(n => !Number.isNaN(n));
-        }
-        catch {
-            return [];
+    try {
+        if (isWindows()) {
+            const { stdout } = await execFileAsync("netstat", ["-ano"]);
+            const match = stdout
+                .split("\n")
+                .find(line => line.includes(`:${port}`) && line.includes("LISTENING"));
+            if (!match)
+                return [];
+            const pid = Number(match.trim().split(/\s+/).at(-1));
+            return Number.isNaN(pid) ? [] : [pid];
         }
-    };
+        const { stdout } = await execFileAsync("lsof", ["-ti", `tcp:${port}`, "-sTCP:LISTEN"]);
+        return stdout.trim().split("\n").filter(Boolean).map(Number)
+            .filter(n => !Number.isNaN(n))
+            // Belt and braces: whatever the listing says, killing by port must
+            // never target the process doing the killing.
+            .filter(pid => pid !== process.pid);
+    }
+    catch {
+        return [];
+    }
+}
+async function killByPort(port) {
+    const { execFile } = await import("child_process");
+    const { promisify } = await import("util");
+    const execFileAsync = promisify(execFile);
     try {
         return await killPortAndWait(port, {
-            listPids,
+            listPids: listListeningPids,
             // Windows has no signals: taskkill /F is the only lever, so both the
             // graceful and forced step map onto it.
             kill: (pid, signal) => {

package/dist/providers/anthropic/usage-refresher.js

@@ -1,195 +1,31 @@
+import { UsageRefresher } from "../../proxy/usage-refresher.js";
 import { fetchAnthropicUsage } from "./usage.js";
-const SUCCESS_REFRESH_MS = 5 * 60_000;
-const FAILURE_BACKOFF_MS = [60_000, 2 * 60_000, 5 * 60_000, 15 * 60_000];
-const DEFAULT_STARTUP_STAGGER_MS = 250;
-const MAX_CONCURRENT_REFRESHES = 2;
-const RECONCILE_INTERVAL_MS = 60_000;
 /**
- * Schedules bounded usage refreshes without becoming a source of routing or
- * health traffic. Account identity, rather than ID alone, owns both work and
- * result application so an account replacement cannot receive stale data.
+ * The Anthropic instantiation of the shared usage scheduler (see
+ * proxy/usage-refresher.ts for the timing/identity guarantees): fetches the
+ * OAuth usage endpoint and lands snapshots on `account.rateLimits.usage`,
+ * downgrading prior data to "stale" (or marking "unavailable") on failure.
  */
-export class AnthropicUsageRefresher {
-    pool;
-    fetchUsage;
-    now;
-    startupStaggerMs;
-    maxConcurrent;
-    timers = new Map();
-    inFlight = new Map();
-    resolvers = new Map();
-    queued = new Set();
-    failures = new Map();
-    reconcileTimer;
-    active = 0;
-    started = false;
-    stopped = false;
+export class AnthropicUsageRefresher extends UsageRefresher {
     constructor(pool, options = {}) {
-        this.pool = pool;
-        this.fetchUsage = options.fetchUsage ?? fetchAnthropicUsage;
-        this.now = options.now ?? Date.now;
-        this.startupStaggerMs = Math.max(0, options.startupStaggerMs ?? DEFAULT_STARTUP_STAGGER_MS);
-        this.maxConcurrent = Math.max(1, Math.floor(options.maxConcurrent ?? MAX_CONCURRENT_REFRESHES));
-    }
-    /** Begin staggered startup work for the accounts currently in the pool. */
-    start() {
-        if (this.started)
-            return;
-        this.started = true;
-        this.stopped = false;
-        this.reconcile(true);
-        this.reconcileTimer = setInterval(() => this.reconcile(), RECONCILE_INTERVAL_MS);
-    }
-    /** Cancel scheduled work. In-flight calls may settle, but cannot reschedule. */
-    stop() {
-        if (!this.started)
-            return;
-        this.started = false;
-        this.stopped = true;
-        if (this.reconcileTimer)
-            clearInterval(this.reconcileTimer);
-        this.reconcileTimer = undefined;
-        for (const timer of this.timers.values())
-            clearTimeout(timer);
-        this.timers.clear();
-        for (const account of this.queued) {
-            this.resolvers.get(account)?.({ ok: false, reason: "network" });
-            this.resolvers.delete(account);
-            this.inFlight.delete(account);
-        }
-        this.queued.clear();
-    }
-    /** Join or initiate the one usage refresh owned by this exact account object. */
-    refreshNow(account) {
-        const existing = this.inFlight.get(account);
-        if (existing)
-            return existing;
-        if (this.stopped)
-            return Promise.resolve({ ok: false, reason: "network" });
-        const scheduled = this.timers.get(account);
-        if (scheduled) {
-            clearTimeout(scheduled);
-            this.timers.delete(account);
-        }
-        let resolve;
-        const pending = new Promise(done => { resolve = done; });
-        this.inFlight.set(account, pending);
-        this.resolvers.set(account, resolve);
-        this.queued.add(account);
-        this.runQueued();
-        return pending;
-    }
-    /** Start a refresh after any request that was already in flight at call time. */
-    refreshAfterCurrent(account) {
-        const existing = this.inFlight.get(account);
-        return existing
-            ? existing.then(() => this.refreshNow(account))
-            : this.refreshNow(account);
-    }
-    reconcile(startup = false) {
-        if (!this.started)
-            return;
-        const accounts = this.pool.getAll();
-        const current = new Set(accounts);
-        for (const [account, timer] of this.timers) {
-            if (!current.has(account)) {
-                clearTimeout(timer);
-                this.timers.delete(account);
-            }
-        }
-        for (const account of [...this.queued]) {
-            if (!current.has(account)) {
-                this.queued.delete(account);
-                this.resolvers.get(account)?.({ ok: false, reason: "network" });
-                this.resolvers.delete(account);
-                this.inFlight.delete(account);
-            }
-        }
-        for (const account of this.failures.keys()) {
-            if (!current.has(account))
-                this.failures.delete(account);
-        }
-        accounts.forEach((account, index) => {
-            if (!this.timers.has(account) && !this.inFlight.has(account) && !this.queued.has(account)) {
-                if (startup)
-                    this.schedule(account, index * this.startupStaggerMs);
-                else
-                    void this.refreshNow(account);
-            }
+        const now = options.now ?? Date.now;
+        super(pool, {
+            fetchUsage: options.fetchUsage ?? fetchAnthropicUsage,
+            cancelledResult: () => ({ ok: false, reason: "network" }),
+            applyResult: (account, result) => {
+                if (result.ok) {
+                    account.rateLimits = { ...account.rateLimits, usage: result.snapshot };
+                    return;
+                }
+                const prior = account.rateLimits.usage;
+                const usage = prior
+                    ? { ...prior, fetchStatus: "stale" }
+                    : { modelLimits: [], fetchedAt: now(), fetchStatus: "unavailable" };
+                account.rateLimits = { ...account.rateLimits, usage };
+            },
+            ...(options.now !== undefined ? { now: options.now } : {}),
+            ...(options.startupStaggerMs !== undefined ? { startupStaggerMs: options.startupStaggerMs } : {}),
+            ...(options.maxConcurrent !== undefined ? { maxConcurrent: options.maxConcurrent } : {}),
         });
     }
-    schedule(account, delayMs) {
-        if (!this.started || this.pool.findById(account.id) !== account)
-            return;
-        const timer = setTimeout(() => {
-            this.timers.delete(account);
-            this.reconcile();
-            void this.refreshNow(account);
-        }, delayMs);
-        this.timers.set(account, timer);
-    }
-    runQueued() {
-        while (this.active < this.maxConcurrent) {
-            const account = this.queued.values().next().value;
-            if (!account)
-                return;
-            this.queued.delete(account);
-            if (this.pool.findById(account.id) !== account) {
-                this.resolvers.get(account)?.({ ok: false, reason: "network" });
-                this.resolvers.delete(account);
-                this.inFlight.delete(account);
-                continue;
-            }
-            this.startRequest(account);
-        }
-    }
-    startRequest(account) {
-        this.active++;
-        const operation = this.inFlight.get(account);
-        const resolve = this.resolvers.get(account);
-        if (!operation || !resolve) {
-            this.active--;
-            return;
-        }
-        void (async () => {
-            let result;
-            try {
-                result = await this.fetchUsage(account);
-            }
-            catch {
-                result = { ok: false, reason: "network" };
-            }
-            if (this.pool.findById(account.id) === account) {
-                this.apply(account, result);
-                if (this.started)
-                    this.schedule(account, this.nextDelay(account, result));
-            }
-            if (this.inFlight.get(account) === operation)
-                this.inFlight.delete(account);
-            this.resolvers.delete(account);
-            this.active--;
-            resolve(result);
-            this.reconcile();
-            this.runQueued();
-        })();
-    }
-    apply(account, result) {
-        if (result.ok) {
-            this.failures.delete(account);
-            account.rateLimits = { ...account.rateLimits, usage: result.snapshot };
-            return;
-        }
-        this.failures.set(account, (this.failures.get(account) ?? 0) + 1);
-        const prior = account.rateLimits.usage;
-        const usage = prior
-            ? { ...prior, fetchStatus: "stale" }
-            : { modelLimits: [], fetchedAt: this.now(), fetchStatus: "unavailable" };
-        account.rateLimits = { ...account.rateLimits, usage };
-    }
-    nextDelay(account, result) {
-        if (result.ok)
-            return SUCCESS_REFRESH_MS;
-        const failures = this.failures.get(account) ?? 1;
-        return FAILURE_BACKOFF_MS[Math.min(failures - 1, FAILURE_BACKOFF_MS.length - 1)];
-    }
 }

package/dist/providers/openai/usage-fetch.js

@@ -0,0 +1,77 @@
+import { applyCodexRateLimits } from "./account-state.js";
+import { parseCodexUsagePayload } from "./usage.js";
+import { UsageRefresher } from "../../proxy/usage-refresher.js";
+/**
+ * The endpoint the Codex CLI's own backend client reads rate limits from
+ * (codex-rs/backend-client, ChatGPT path style). Answers a bearer-only GET
+ * with the JSON twin of the `x-codex-*` response headers — which is what
+ * makes usage visible without burning a request through /codex/responses.
+ */
+export const CODEX_USAGE_ENDPOINT = "https://chatgpt.com/backend-api/wham/usage";
+export async function fetchCodexUsage(account, options = {}) {
+    const fetchImpl = options.fetch ?? globalThis.fetch;
+    const now = options.now ?? Date.now;
+    let response;
+    try {
+        response = await fetchImpl(CODEX_USAGE_ENDPOINT, {
+            headers: { authorization: `Bearer ${account.accessToken}` },
+            signal: AbortSignal.timeout(10_000),
+        });
+    }
+    catch {
+        return { ok: false, reason: "network" };
+    }
+    if (response.status === 401 || response.status === 403)
+        return { ok: false, reason: "auth" };
+    if (!response.ok)
+        return { ok: false, reason: "http" };
+    let body;
+    try {
+        body = await response.json();
+    }
+    catch {
+        return { ok: false, reason: "malformed" };
+    }
+    const update = parseCodexUsagePayload(body, now());
+    return update ? { ok: true, update } : { ok: false, reason: "malformed" };
+}
+/**
+ * The OpenAI/Codex instantiation of the shared usage scheduler: polls the
+ * usage endpoint and feeds the result through `applyCodexRateLimits` — the
+ * same merge the response headers go through — so the dashboard shows an
+ * account's windows right after startup instead of only after its first
+ * routed request. A failed fetch keeps whatever the account already knew;
+ * unlike the Anthropic snapshot there is no per-fetch staleness field, and
+ * header-fed data must not be erased by a flaky poll.
+ */
+export class OpenAIUsageRefresher extends UsageRefresher {
+    constructor(pool, options = {}) {
+        const now = options.now ?? Date.now;
+        const fetchUsage = options.fetchUsage ?? ((account) => fetchCodexUsage(account, { now }));
+        const prepare = options.prepare;
+        super(pool, {
+            fetchUsage: async (account) => {
+                if (prepare) {
+                    let ready;
+                    try {
+                        ready = await prepare(account);
+                    }
+                    catch {
+                        ready = false;
+                    }
+                    if (!ready)
+                        return { ok: false, reason: "auth" };
+                }
+                return fetchUsage(account);
+            },
+            cancelledResult: () => ({ ok: false, reason: "network" }),
+            applyResult: (account, result) => {
+                if (result.ok)
+                    applyCodexRateLimits(account, result.update, now());
+            },
+            ...(options.now !== undefined ? { now: options.now } : {}),
+            ...(options.startupStaggerMs !== undefined ? { startupStaggerMs: options.startupStaggerMs } : {}),
+            ...(options.maxConcurrent !== undefined ? { maxConcurrent: options.maxConcurrent } : {}),
+        });
+    }
+}

package/dist/providers/openai/usage.js

@@ -132,6 +132,122 @@ export function parseCodexRateLimits(headers, nowMs) {
     const credits = parseCredits(headers);
     return { buckets, ...(credits ? { credits } : {}) };
 }
+// ─── Usage endpoint payload (GET chatgpt.com/backend-api/wham/usage) ─────────
+// The JSON twin of the `x-codex-*` header family: the same window fields
+// (used_percent / limit_window_seconds / reset_after_seconds / reset_at)
+// under `rate_limit.{primary,secondary}_window`, named buckets under
+// `additional_rate_limits`, and a `credits` object. Parsed with the same
+// trust rules as the headers — the payload is upstream-controlled data
+// either way.
+function usageNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function usageWindowFromJson(value, nowMs) {
+    if (typeof value !== "object" || value === null)
+        return undefined;
+    const window = value;
+    const percent = usageNumber(window["used_percent"]);
+    if (percent === undefined)
+        return undefined;
+    const nowSec = Math.floor(nowMs / 1000);
+    const horizonSec = nowSec + MAX_TRUSTED_RATE_LIMIT_HORIZON_SEC;
+    let resetAt = 0;
+    const absolute = usageNumber(window["reset_at"]);
+    if (absolute !== undefined && absolute > 0) {
+        const seconds = absolute > MS_TIMESTAMP_THRESHOLD ? Math.floor(absolute / 1000) : Math.floor(absolute);
+        if (seconds > nowSec && seconds <= horizonSec)
+            resetAt = seconds;
+    }
+    if (resetAt === 0) {
+        // Same fallback the header parser applies: an unusable absolute reset
+        // must not discard a usable relative one (see parseResetAtSeconds).
+        const relative = usageNumber(window["reset_after_seconds"]);
+        if (relative !== undefined && relative > 0) {
+            const candidate = nowSec + Math.floor(relative);
+            if (candidate <= horizonSec)
+                resetAt = candidate;
+        }
+    }
+    const windowSeconds = usageNumber(window["limit_window_seconds"]);
+    return {
+        utilization: Math.max(0, Math.min(1, percent / 100)),
+        resetAt,
+        windowMinutes: windowSeconds !== undefined && windowSeconds > 0
+            ? Math.min(Math.floor(windowSeconds / 60), MAX_TRUSTED_WINDOW_MINUTES)
+            : 0,
+    };
+}
+function usageBucketFromJson(limitId, limitName, rateLimit, nowMs) {
+    if (typeof rateLimit !== "object" || rateLimit === null)
+        return undefined;
+    const windows = rateLimit;
+    const primary = usageWindowFromJson(windows["primary_window"], nowMs);
+    const secondary = usageWindowFromJson(windows["secondary_window"], nowMs);
+    if (!primary && !secondary)
+        return undefined;
+    return {
+        limitId,
+        ...(limitName ? { limitName: limitName.slice(0, 64) } : {}),
+        ...(primary ? { primary } : {}),
+        ...(secondary ? { secondary } : {}),
+    };
+}
+/**
+ * Parse a usage-endpoint response body into the same update shape the
+ * response-header parser produces, so both feed `applyCodexRateLimits`
+ * identically. Returns null when the body is not a usage payload at all
+ * (e.g. an error object) — as opposed to a payload with no windows, which
+ * is a valid empty update.
+ */
+export function parseCodexUsagePayload(value, nowMs) {
+    if (typeof value !== "object" || value === null)
+        return null;
+    const payload = value;
+    if (typeof payload["rate_limit"] !== "object" || payload["rate_limit"] === null)
+        return null;
+    const buckets = [];
+    const defaultBucket = usageBucketFromJson(DEFAULT_CODEX_LIMIT_ID, undefined, payload["rate_limit"], nowMs);
+    if (defaultBucket)
+        buckets.push(defaultBucket);
+    const additional = payload["additional_rate_limits"];
+    if (Array.isArray(additional)) {
+        for (const entry of additional) {
+            if (typeof entry !== "object" || entry === null)
+                continue;
+            const record = entry;
+            const limitName = typeof record["limit_name"] === "string" ? record["limit_name"].trim() : undefined;
+            const idSource = typeof record["metered_feature"] === "string" && record["metered_feature"].trim()
+                ? record["metered_feature"]
+                : limitName;
+            if (!idSource)
+                continue;
+            const limitId = normalizeCodexLimitId(idSource);
+            if (!/^[a-z0-9_]{1,64}$/.test(limitId) || limitId === DEFAULT_CODEX_LIMIT_ID)
+                continue;
+            const bucket = usageBucketFromJson(limitId, limitName, record["rate_limit"], nowMs);
+            if (bucket)
+                buckets.push(bucket);
+        }
+    }
+    let credits;
+    const rawCredits = payload["credits"];
+    if (typeof rawCredits === "object" && rawCredits !== null) {
+        const record = rawCredits;
+        const hasCredits = typeof record["has_credits"] === "boolean" ? record["has_credits"] : undefined;
+        const unlimited = typeof record["unlimited"] === "boolean" ? record["unlimited"] : undefined;
+        if (hasCredits !== undefined || unlimited !== undefined) {
+            const balance = typeof record["balance"] === "string"
+                ? record["balance"].replace(CONTROL_CHAR_PATTERN, "").trim()
+                : undefined;
+            credits = {
+                hasCredits: hasCredits === true,
+                unlimited: unlimited === true,
+                ...(balance ? { balance: balance.slice(0, 32) } : {}),
+            };
+        }
+    }
+    return { buckets, ...(credits ? { credits } : {}) };
+}
 export function resolveActiveLimit(headers) {
     const raw = headerString(headers, "x-codex-active-limit")?.trim();
     if (!raw)

package/dist/proxy/server.js

@@ -25,6 +25,8 @@ import chalk from "chalk";
 import { SessionRouter } from "./session-router.js";
 import { createAnthropicProxy } from "./anthropic-proxy.js";
 import { AnthropicUsageRefresher } from "../providers/anthropic/usage-refresher.js";
+import { OpenAIUsageRefresher } from "../providers/openai/usage-fetch.js";
+import { createAnthropicUsageCapture } from "./usage-capture.js";
 import { canUseExtraUsage } from "../providers/anthropic/usage.js";
 import { applyUpstreamFailureRoutingDetailed, reconcileAmbiguousRateLimitCooldown, routeFailureDetails, routeReasonDetails, } from "./lease-lifecycle.js";
 import { persistProviderEnabledState } from "./provider-routing.js";
@@ -429,6 +431,15 @@ export async function startServer(opts = {}) {
     startOpenAIRefreshLoop(openAIAccounts, persistOpenAIAccounts);
     const usageRefresher = new AnthropicUsageRefresher(pool);
     usageRefresher.start();
+    // Codex usage otherwise arrives only on response headers, so a freshly
+    // restarted daemon showed empty OpenAI bars until the first request
+    // happened to route there. Poll the usage endpoint the Codex CLI itself
+    // uses, so `cc-router status` is populated immediately — mirroring the
+    // Anthropic refresher above.
+    const openAIUsageRefresher = new OpenAIUsageRefresher(openAIPool, {
+        prepare: (account) => prepareOpenAIAccountForRequest(account, openAIAccounts, persistOpenAIAccounts),
+    });
+    openAIUsageRefresher.start();
     const app = express();
     const proxyRequestTimeoutMs = getProxyRequestTimeoutMs();
     // ─── Proxy auth middleware ─────────────────────────────────────────────────
@@ -1035,8 +1046,11 @@ export async function startServer(opts = {}) {
                 //   message_start  → input_tokens, cache_read/creation_input_tokens
                 //   message_delta   → output_tokens
                 // Non-streaming JSON carries all fields in a single usage object.
-                // We use incremental line parsing (not buffering) so we can capture
-                // both events without holding the full stream in memory.
+                // The proxy is byte-transparent and the client's accept-encoding makes
+                // upstream compress, so the capture decompresses its own copy of the
+                // stream (see usage-capture.ts) — previously compressed responses were
+                // skipped, which in practice was EVERY response: no cache rate or
+                // token counts ever appeared on Anthropic activity rows.
                 const contentType = String(proxyRes.headers["content-type"] ?? "");
                 const encoding = String(proxyRes.headers["content-encoding"] ?? "");
                 const isCompressed = /gzip|br|deflate/.test(encoding);
@@ -1044,51 +1058,17 @@ export async function startServer(opts = {}) {
                 entry.streamLifecycle = streamTracker.state;
                 streamTracker.attach(proxyRes, response);
                 proxyRes.on("data", (chunk) => streamTracker.observeChunk(chunk));
-                if (!isCompressed && (contentType.includes("text/event-stream") || contentType.includes("application/json"))) {
-                    const isSSE = contentType.includes("text/event-stream");
-                    if (isSSE) {
-                        let lineBuf = "";
-                        let gotInput = false;
-                        let gotOutput = false;
-                        proxyRes.on("data", (chunk) => {
-                            if (gotInput && gotOutput)
-                                return;
-                            lineBuf += chunk.toString("utf8");
-                            const lines = lineBuf.split("\n");
-                            lineBuf = lines.pop() ?? ""; // keep incomplete last line
-                            for (const line of lines) {
-                                if (!line.startsWith("data: "))
-                                    continue;
-                                try {
-                                    const evt = JSON.parse(line.slice(6));
-                                    if (!gotInput && evt.type === "message_start" && evt.message?.usage) {
-                                        applyInputUsage(entry, evt.message.usage);
-                                        gotInput = true;
-                                    }
-                                    if (!gotOutput && evt.type === "message_delta" && evt.usage) {
-                                        applyOutputUsage(entry, evt.usage);
-                                        gotOutput = true;
-                                    }
-                                }
-                                catch { /* partial JSON across chunk boundary — next chunk will complete it */ }
-                            }
-                        });
-                    }
-                    else {
-                        // Non-streaming JSON: buffer full body then parse once
-                        let buf = "";
-                        proxyRes.on("data", (chunk) => { buf += chunk.toString("utf8"); });
-                        proxyRes.on("end", () => {
-                            try {
-                                const body = JSON.parse(buf);
-                                if (body.usage) {
-                                    applyInputUsage(entry, body.usage);
-                                    applyOutputUsage(entry, body.usage);
-                                }
-                            }
-                            catch { /* ignore */ }
-                        });
-                    }
+                const usageCapture = createAnthropicUsageCapture({
+                    contentType,
+                    contentEncoding: encoding,
+                    // Mutates the already-logged entry in place; the dashboard picks the
+                    // values up on its next poll.
+                    onInputUsage: (usage) => applyInputUsage(entry, usage),
+                    onOutputUsage: (usage) => applyOutputUsage(entry, usage),
+                });
+                if (usageCapture) {
+                    proxyRes.on("data", (chunk) => usageCapture.write(chunk));
+                    proxyRes.on("end", () => usageCapture.end());
                 }
             },
             error: (err, _req, res) => {
@@ -1179,6 +1159,7 @@ export async function startServer(opts = {}) {
     const shutdown = () => {
         console.log(chalk.yellow("\nShutting down — saving tokens..."));
         usageRefresher.stop();
+        openAIUsageRefresher.stop();
         saveAccounts(pool.getAll());
         if (managesPidFile()) {
             removePid();

package/dist/proxy/usage-capture.js

@@ -0,0 +1,119 @@
+import { createBrotliDecompress, createGunzip, createInflate } from "node:zlib";
+/** Non-streaming bodies are buffered for one parse at end-of-stream; a body
+ *  past this size stops being buffered (usage is best-effort diagnostics —
+ *  unbounded buffering of a pathological body is not worth it). */
+const MAX_JSON_BODY_BYTES = 20 * 1024 * 1024;
+function createDecoder(contentEncoding) {
+    const encoding = contentEncoding.trim().toLowerCase();
+    // `identity` and absent mean the bytes are already readable.
+    if (encoding === "" || encoding === "identity")
+        return null;
+    if (encoding === "gzip" || encoding === "x-gzip")
+        return createGunzip();
+    if (encoding === "br")
+        return createBrotliDecompress();
+    if (encoding === "deflate")
+        return createInflate();
+    // Multi-codings ("gzip, br") and unknown codings are not worth chasing.
+    return undefined;
+}
+export function createAnthropicUsageCapture(options) {
+    const isSSE = options.contentType.includes("text/event-stream");
+    const isJSON = options.contentType.includes("application/json");
+    if (!isSSE && !isJSON)
+        return null;
+    const decoder = createDecoder(options.contentEncoding);
+    if (decoder === undefined)
+        return null;
+    let dead = false;
+    const die = () => {
+        if (dead)
+            return;
+        dead = true;
+        decoder?.destroy();
+    };
+    // ── SSE: incremental line parsing, stop once both events were seen ────────
+    let lineBuf = "";
+    let gotInput = false;
+    let gotOutput = false;
+    const parseSSEChunk = (text) => {
+        lineBuf += text;
+        const lines = lineBuf.split("\n");
+        lineBuf = lines.pop() ?? ""; // keep incomplete last line
+        for (const line of lines) {
+            if (!line.startsWith("data: "))
+                continue;
+            try {
+                const evt = JSON.parse(line.slice(6));
+                if (!gotInput && evt.type === "message_start" && evt.message?.usage) {
+                    options.onInputUsage(evt.message.usage);
+                    gotInput = true;
+                }
+                if (!gotOutput && evt.type === "message_delta" && evt.usage) {
+                    options.onOutputUsage(evt.usage);
+                    gotOutput = true;
+                }
+                // Everything of interest has been seen — stop paying for the rest of
+                // the stream (and free the decompressor's zlib state).
+                if (gotInput && gotOutput)
+                    die();
+            }
+            catch { /* partial JSON across chunk boundary — next chunk completes it */ }
+        }
+    };
+    // ── Non-streaming JSON: buffer, parse once at end ─────────────────────────
+    let jsonBuf = "";
+    const parseJSONBody = () => {
+        try {
+            const body = JSON.parse(jsonBuf);
+            if (body.usage) {
+                options.onInputUsage(body.usage);
+                options.onOutputUsage(body.usage);
+            }
+        }
+        catch { /* not a JSON body after all */ }
+    };
+    const consume = (chunk) => {
+        if (dead)
+            return;
+        if (isSSE) {
+            parseSSEChunk(chunk.toString("utf8"));
+            return;
+        }
+        if (jsonBuf.length + chunk.length > MAX_JSON_BODY_BYTES) {
+            die();
+            return;
+        }
+        jsonBuf += chunk.toString("utf8");
+    };
+    const finish = () => {
+        if (dead)
+            return;
+        if (isJSON)
+            parseJSONBody();
+        dead = true;
+    };
+    if (!decoder) {
+        return {
+            write: (chunk) => consume(chunk),
+            end: () => finish(),
+        };
+    }
+    decoder.on("data", (chunk) => consume(chunk));
+    decoder.on("end", () => finish());
+    // Corrupt or truncated compressed data — the capture just stops; the
+    // proxied bytes were never ours to begin with.
+    decoder.on("error", () => die());
+    return {
+        write: (chunk) => {
+            if (dead)
+                return;
+            decoder.write(chunk);
+        },
+        end: () => {
+            if (dead)
+                return;
+            decoder.end();
+        },
+    };
+}

package/dist/proxy/usage-refresher.js

@@ -0,0 +1,188 @@
+const SUCCESS_REFRESH_MS = 5 * 60_000;
+const FAILURE_BACKOFF_MS = [60_000, 2 * 60_000, 5 * 60_000, 15 * 60_000];
+const DEFAULT_STARTUP_STAGGER_MS = 250;
+const MAX_CONCURRENT_REFRESHES = 2;
+const RECONCILE_INTERVAL_MS = 60_000;
+/**
+ * Schedules bounded usage refreshes without becoming a source of routing or
+ * health traffic. Account identity, rather than ID alone, owns both work and
+ * result application so an account replacement cannot receive stale data.
+ * Provider-agnostic: what "usage" is and how a result lands on the account
+ * comes in through the hooks (see AnthropicUsageRefresher /
+ * OpenAIUsageRefresher).
+ */
+export class UsageRefresher {
+    pool;
+    hooks;
+    now;
+    startupStaggerMs;
+    maxConcurrent;
+    timers = new Map();
+    inFlight = new Map();
+    resolvers = new Map();
+    queued = new Set();
+    failures = new Map();
+    reconcileTimer;
+    active = 0;
+    started = false;
+    stopped = false;
+    constructor(pool, hooks) {
+        this.pool = pool;
+        this.hooks = hooks;
+        this.now = hooks.now ?? Date.now;
+        this.startupStaggerMs = Math.max(0, hooks.startupStaggerMs ?? DEFAULT_STARTUP_STAGGER_MS);
+        this.maxConcurrent = Math.max(1, Math.floor(hooks.maxConcurrent ?? MAX_CONCURRENT_REFRESHES));
+    }
+    /** Begin staggered startup work for the accounts currently in the pool. */
+    start() {
+        if (this.started)
+            return;
+        this.started = true;
+        this.stopped = false;
+        this.reconcile(true);
+        this.reconcileTimer = setInterval(() => this.reconcile(), RECONCILE_INTERVAL_MS);
+    }
+    /** Cancel scheduled work. In-flight calls may settle, but cannot reschedule. */
+    stop() {
+        if (!this.started)
+            return;
+        this.started = false;
+        this.stopped = true;
+        if (this.reconcileTimer)
+            clearInterval(this.reconcileTimer);
+        this.reconcileTimer = undefined;
+        for (const timer of this.timers.values())
+            clearTimeout(timer);
+        this.timers.clear();
+        for (const account of this.queued) {
+            this.resolvers.get(account)?.(this.hooks.cancelledResult());
+            this.resolvers.delete(account);
+            this.inFlight.delete(account);
+        }
+        this.queued.clear();
+    }
+    /** Join or initiate the one usage refresh owned by this exact account object. */
+    refreshNow(account) {
+        const existing = this.inFlight.get(account);
+        if (existing)
+            return existing;
+        if (this.stopped)
+            return Promise.resolve(this.hooks.cancelledResult());
+        const scheduled = this.timers.get(account);
+        if (scheduled) {
+            clearTimeout(scheduled);
+            this.timers.delete(account);
+        }
+        let resolve;
+        const pending = new Promise(done => { resolve = done; });
+        this.inFlight.set(account, pending);
+        this.resolvers.set(account, resolve);
+        this.queued.add(account);
+        this.runQueued();
+        return pending;
+    }
+    /** Start a refresh after any request that was already in flight at call time. */
+    refreshAfterCurrent(account) {
+        const existing = this.inFlight.get(account);
+        return existing
+            ? existing.then(() => this.refreshNow(account))
+            : this.refreshNow(account);
+    }
+    reconcile(startup = false) {
+        if (!this.started)
+            return;
+        const accounts = this.pool.getAll();
+        const current = new Set(accounts);
+        for (const [account, timer] of this.timers) {
+            if (!current.has(account)) {
+                clearTimeout(timer);
+                this.timers.delete(account);
+            }
+        }
+        for (const account of [...this.queued]) {
+            if (!current.has(account)) {
+                this.queued.delete(account);
+                this.resolvers.get(account)?.(this.hooks.cancelledResult());
+                this.resolvers.delete(account);
+                this.inFlight.delete(account);
+            }
+        }
+        for (const account of this.failures.keys()) {
+            if (!current.has(account))
+                this.failures.delete(account);
+        }
+        accounts.forEach((account, index) => {
+            if (!this.timers.has(account) && !this.inFlight.has(account) && !this.queued.has(account)) {
+                if (startup)
+                    this.schedule(account, index * this.startupStaggerMs);
+                else
+                    void this.refreshNow(account);
+            }
+        });
+    }
+    schedule(account, delayMs) {
+        if (!this.started || this.pool.findById(account.id) !== account)
+            return;
+        const timer = setTimeout(() => {
+            this.timers.delete(account);
+            this.reconcile();
+            void this.refreshNow(account);
+        }, delayMs);
+        this.timers.set(account, timer);
+    }
+    runQueued() {
+        while (this.active < this.maxConcurrent) {
+            const account = this.queued.values().next().value;
+            if (!account)
+                return;
+            this.queued.delete(account);
+            if (this.pool.findById(account.id) !== account) {
+                this.resolvers.get(account)?.(this.hooks.cancelledResult());
+                this.resolvers.delete(account);
+                this.inFlight.delete(account);
+                continue;
+            }
+            this.startRequest(account);
+        }
+    }
+    startRequest(account) {
+        this.active++;
+        const operation = this.inFlight.get(account);
+        const resolve = this.resolvers.get(account);
+        if (!operation || !resolve) {
+            this.active--;
+            return;
+        }
+        void (async () => {
+            let result;
+            try {
+                result = await this.hooks.fetchUsage(account);
+            }
+            catch {
+                result = this.hooks.cancelledResult();
+            }
+            if (this.pool.findById(account.id) === account) {
+                if (result.ok)
+                    this.failures.delete(account);
+                else
+                    this.failures.set(account, (this.failures.get(account) ?? 0) + 1);
+                this.hooks.applyResult(account, result);
+                if (this.started)
+                    this.schedule(account, this.nextDelay(account, result));
+            }
+            if (this.inFlight.get(account) === operation)
+                this.inFlight.delete(account);
+            this.resolvers.delete(account);
+            this.active--;
+            resolve(result);
+            this.reconcile();
+            this.runQueued();
+        })();
+    }
+    nextDelay(account, result) {
+        if (result.ok)
+            return SUCCESS_REFRESH_MS;
+        const failures = this.failures.get(account) ?? 1;
+        return FAILURE_BACKOFF_MS[Math.min(failures - 1, FAILURE_BACKOFF_MS.length - 1)];
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@timo972/cc-router",
-  "version": "0.10.0-rc.3",
+  "version": "0.10.0-rc.5",
   "description": "Cache-aware session router for Claude Max OAuth tokens — use multiple Claude Max accounts with Claude Code",
   "type": "module",
   "bin": {