@timo972/cc-router 0.10.0-rc.2 → 0.10.0-rc.4

package/CHANGELOG.md

@@ -8,8 +8,71 @@ This project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+### 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
+  (`PATCH /cc-router/accounts/:id` with `{"id": ...}`): pool, session router,
+  and accounts.json move together, and are rolled back together if persistence
+  fails. Sticky sessions keep their prompt-cache affinity through the rename.
+  With no proxy running the record is renamed on disk. A proxy from before
+  this feature answers the PATCH with 200 having silently ignored the field —
+  that is detected and reported as an error rather than falling back to a disk
+  write its refresh loop would overwrite. The id namespace is shared across
+  both providers, so a rename onto any existing account name is refused (409).
+
+- The health endpoint reports the daemon's version, and the dashboard shows a
+  version-mismatch banner when the daemon runs a different build than the CLI
+  rendering it. A service manager can keep an old build alive long after an
+  upgrade — launchd pins the versioned pnpm store path in its plist, so the
+  daemon silently stays on the old version across upgrades and even reboots —
+  and every log row and account view on the dashboard comes from that build.
+  Until now nothing surfaced this: a fix could ship, the package could update,
+  and the dashboard would still render the old daemon's output as if the new
+  version were broken. A daemon that reports no version at all predates the
+  field, which is itself proof it is outdated, and banners the same way.
+- The activity list scrolls to follow its selection. The dashboard renders the
+  newest 20 of up to 50 entries, but the arrow keys would walk the selection
+  through all 50 — past row 20 the highlight left the screen while the detail
+  panel kept updating for rows that were not visible. The window now shifts by
+  one row when the selection steps past its bottom or top edge, stays put while
+  the selection moves inside it, and re-clamps when new entries push the
+  selected row (which is timestamp-anchored) out of the stored window.
+
 ### Fixed
 
+- `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-accounts.js

@@ -1,10 +1,11 @@
 import chalk from "chalk";
-import { loadAccounts, loadOpenAIAccounts, accountsFileExists, upsertAccountRecord, removeAccountRecordById, readConfig, serialize } from "../config/manager.js";
+import { loadAccounts, loadOpenAIAccounts, accountsFileExists, upsertAccountRecord, removeAccountRecordById, renameAccountRecordById, readConfig, serialize } from "../config/manager.js";
 import { saveAccounts } from "../proxy/token-refresher.js";
 import { formatExpiry, redactToken } from "../utils/token-extractor.js";
 import { PROXY_PORT } from "../config/paths.js";
 import { createOpenAIAccountRecord } from "../providers/openai/account-record.js";
 import { loginOpenAIWithDeviceCode } from "../providers/openai/device-oauth.js";
+import { isValidAccountId } from "../proxy/account-rename.js";
 export function registerAccounts(program) {
     const accounts = program
         .command("accounts")
@@ -233,6 +234,47 @@ export function registerAccounts(program) {
             console.log(chalk.yellow("  No accounts left. Run: cc-router setup"));
         }
     });
+    accounts
+        .command("rename <id> <new-id>")
+        .description("Rename an account — its routing state and sticky sessions follow the new name")
+        .action(async (id, newId) => {
+        if (!accountsFileExists()) {
+            console.log(chalk.yellow("No accounts configured."));
+            return;
+        }
+        if (!isValidAccountId(newId)) {
+            console.log(chalk.red(`✗ "${newId}" is not a valid account name.`));
+            console.log(chalk.gray("  1-64 characters: alphanumeric start, then letters, digits, dots, underscores, or dashes."));
+            process.exit(1);
+        }
+        const { ids: existingIds } = mergeAccountInventory(loadAccounts().map(a => a.id), loadOpenAIAccounts().map(a => a.id), await fetchLiveStats());
+        if (!existingIds.includes(id)) {
+            console.log(chalk.red(`✗ Account "${id}" not found.`));
+            console.log(chalk.gray(`  Available: ${existingIds.join(", ")}`));
+            process.exit(1);
+        }
+        if (id === newId) {
+            console.log(chalk.gray(`Account is already named "${newId}".`));
+            return;
+        }
+        if (existingIds.includes(newId)) {
+            console.log(chalk.red(`✗ An account named "${newId}" already exists.`));
+            process.exit(1);
+        }
+        let result;
+        try {
+            result = await renameAccountRuntimeAware(id, newId);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            console.log(chalk.red(`✗ Could not rename "${id}": ${message}`));
+            process.exit(1);
+        }
+        console.log(chalk.green(`✓ Renamed "${id}" → "${newId}".`));
+        console.log(result.mode === "live"
+            ? chalk.gray("  Applied to the running proxy — in-flight requests and sticky sessions follow the new name.")
+            : chalk.gray("  Saved to accounts.json — loads on next start: cc-router start"));
+    });
 }
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 /** Tell the user whether the new account is already live or needs a restart. */
@@ -326,6 +368,66 @@ export async function tryRemoveAccountFromRunningProxy(id, options = {}) {
     }
     return true;
 }
+/**
+ * Rename an account on a running proxy. Returns false only when no proxy can
+ * be reached (the caller then renames on disk); HTTP errors are authoritative
+ * and thrown. A 200 whose returned account still carries the old id means the
+ * proxy predates rename support — its patch validation drops unknown fields
+ * and reports success having done nothing — and MUST be an error, not a
+ * fallthrough to disk: that proxy's refresh loop persists its own snapshot
+ * over accounts.json and would silently undo a disk-side rename.
+ */
+export async function tryRenameAccountOnRunningProxy(id, newId, options = {}) {
+    const fetchImpl = options.fetch ?? globalThis.fetch;
+    const baseUrl = (options.baseUrl ?? `http://localhost:${PROXY_PORT}`).replace(/\/+$/, "");
+    const authToken = options.authToken ?? readConfig().proxySecret;
+    let response;
+    try {
+        response = await fetchImpl(`${baseUrl}/cc-router/accounts/${encodeURIComponent(id)}`, {
+            method: "PATCH",
+            headers: {
+                "content-type": "application/json",
+                ...(authToken ? { authorization: `Bearer ${authToken}` } : {}),
+            },
+            body: JSON.stringify({ id: newId }),
+            signal: AbortSignal.timeout(3_000),
+        });
+    }
+    catch {
+        return false;
+    }
+    if (!response.ok) {
+        let detail = "";
+        try {
+            const payload = await response.json();
+            if (typeof payload.error === "string")
+                detail = `: ${payload.error}`;
+        }
+        catch { /* best effort */ }
+        throw new Error(`HTTP ${response.status}${detail}`);
+    }
+    let renamedId;
+    try {
+        const payload = await response.json();
+        renamedId = payload.account?.id;
+    }
+    catch { /* fall through to the mismatch error below */ }
+    if (renamedId !== newId) {
+        throw new Error("the running proxy does not support rename (older version) — update and restart it first: cc-router stop --keep-config && cc-router start");
+    }
+    return true;
+}
+export async function renameAccountRuntimeAware(id, newId, dependencies = {
+    tryRenameLive: tryRenameAccountOnRunningProxy,
+    renameStored: renameAccountRecordById,
+}) {
+    if (await dependencies.tryRenameLive(id, newId))
+        return { mode: "live" };
+    const renamed = dependencies.renameStored(id, newId);
+    if (!renamed)
+        throw new Error(`Account "${id}" disappeared before it could be renamed`);
+    return { mode: "stored", renamed };
+}
 export async function removeAccountRuntimeAware(id, dependencies = {
     tryRemoveLive: tryRemoveAccountFromRunningProxy,
     removeStored: removeAccountRecordById,

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/config/manager.js

@@ -90,6 +90,25 @@ export function removeAccountRecordById(id) {
     writeAccountsAtomicToPath(ACCOUNTS_PATH, existing.filter(a => a.id !== id));
     return removed;
 }
+/**
+ * Rename a stored account record in place, keeping every other field. The
+ * uniqueness check spans ALL providers — both live in one accounts.json and
+ * one URL namespace, so two records sharing an id would be unaddressable.
+ * Returns the renamed record, or null if no record has `oldId`.
+ */
+export function renameAccountRecordById(oldId, newId) {
+    ensureConfigDir();
+    const existing = readAccountsRaw();
+    const target = existing.find(a => a.id === oldId) ?? null;
+    if (!target)
+        return null;
+    if (newId !== oldId && existing.some(a => a.id === newId)) {
+        throw new Error(`An account named "${newId}" already exists`);
+    }
+    target.id = newId;
+    writeAccountsAtomicToPath(ACCOUNTS_PATH, existing);
+    return target;
+}
 function normalizeAccountProvider(record) {
     return record.provider === "openai_subscription"
         ? "openai_subscription"

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/token-pool.js

@@ -175,6 +175,28 @@ export class OpenAITokenPool {
     findById(id) {
         return this.accounts.find(account => account.id === id) ?? null;
     }
+    /**
+     * Change an account's id in place. The in-flight counter is keyed by id and
+     * must move with it — an open lease's release() re-reads `account.id`, so
+     * after a rename it decrements the NEW key, which would otherwise never
+     * have been incremented. Cooldowns are keyed by the account object and
+     * follow the rename untouched. Returns the renamed account, or null if the
+     * id was not found. Callers are responsible for id-uniqueness and for
+     * session-binding migration. Mirrors `TokenPool.renameAccount`.
+     */
+    renameAccount(oldId, newId) {
+        const account = this.findById(oldId);
+        if (!account)
+            return null;
+        if (newId !== oldId) {
+            const load = this.inFlight.get(oldId);
+            this.inFlight.delete(oldId);
+            if (load !== undefined)
+                this.inFlight.set(newId, load);
+            account.id = newId;
+        }
+        return account;
+    }
     /**
      * Drop every piece of per-account routing state after the account has been
      * removed from the shared `accounts` array. The array splice itself is owned

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 } : {}),
+        });
+    }
+}