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

package/CHANGELOG.md

@@ -8,7 +8,89 @@ This project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
-Nothing yet.
+### Added
+
+- `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
+
+- 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
+  bare entry type and read `route` under a blank client column, beside
+  `POST /messages` and `cli` on the Claude rows. Codex CLI traffic now reports
+  a `codex` source of its own rather than borrowing `cli`, which the detail
+  panel spells out as "Claude Code"; a `/v1/messages` request that cross-routes
+  to an OpenAI backend is still classified by the client that sent it.
+- An OpenAI account's usage bars are labelled from each window's own duration
+  instead of by position. Codex reports its weekly window in the `primary` slot
+  and leaves `secondary` empty, but the bars assumed primary meant 5h and
+  secondary meant weekly — so an account at 100% of its weekly quota displayed
+  as `5h 100%` next to a `weekly 0%` bar that was really the empty slot. The
+  countdown gave it away: a 5h window cannot reset five days out.
+- A named Codex bucket no longer renders twice. Codex sends an absent window as
+  an all-zero placeholder rather than omitting it, so the empty `secondary` was
+  treated as real and emitted a second row — carrying the same label as the
+  first, because a zero-length window falls through to a guessed one.
+- An account id exactly as long as its column no longer runs into the status
+  next to it (`plus-developer-droidLIMITED`).
+- The status dashboard can enable, disable, and remove OpenAI accounts. Three
+  guards still sent the operator to the CLI for operations the management
+  endpoints had already gained: `e` answered "OpenAI accounts are managed from
+  the CLI", and delete refused both at the keypress and again inside the
+  confirmation, so the second gate would have caught anyone who got past the
+  first. The cap keys (`w`/`s`) never had such a check, which is what made the
+  inconsistency visible.
+- `cc-router start` no longer has to be run twice. In service mode it wrote the
+  LaunchAgent plist and immediately bootstrapped it, but `launchctl bootout`
+  returns as soon as launchd accepts the request — not once the job is gone.
+  Bootstrapping the same label during that window fails with
+  `Bootstrap failed: 5: Input/output error`, and the legacy `launchctl load`
+  fallback fails identically, so the command printed a warning and exited
+  successfully with nothing running. It now waits for launchd to release the
+  label before loading, and retries the bootstrap until a deadline.
+- A failed start is no longer reported as a success. Service mode installed the
+  service and returned without checking that anything was listening — the
+  background path already health-checked, the service path did not. It now
+  polls the health endpoint and exits non-zero with the log location if the
+  proxy never answers.
+- `cc-router stop` waits for the proxy to actually exit before reporting
+  success. With no PID file the stop fell through to killing by port, which
+  returned as soon as SIGTERM was sent; a `start` issued straight afterwards
+  then raced the still-running process. The port path now waits for the
+  process to die and escalates to SIGKILL, matching the PID path.
+- A service-managed proxy writes a PID file. `writePid`/`removePid` were gated
+  on `CC_ROUTER_DAEMON`, which the LaunchAgent and systemd unit never set —
+  they set `CC_ROUTER_SERVICE` — so every service-managed instance left no PID
+  behind and took the weaker port-based stop path.
 
 ---
 

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

@@ -4,7 +4,7 @@ import { PROXY_PORT, LITELLM_PORT, ACCOUNTS_PATH } from "../config/paths.js";
 import { accountsFileExists, readConfig, writeConfig, generateProxySecret, } from "../config/manager.js";
 import { writeClaudeSettings } from "../utils/claude-config.js";
 import { checkForUpdate, performUpdate, PKG_NAME } from "../utils/self-update.js";
-import { launchDaemon } from "../daemon/launcher.js";
+import { launchDaemon, waitForHealth } from "../daemon/launcher.js";
 import { installService } from "../daemon/service.js";
 import { getLocalIPs } from "../utils/network.js";
 export function registerStart(program) {
@@ -79,6 +79,19 @@ export function registerStart(program) {
         }
         if (prefs.mode === "service") {
             await installService(prefs.serverMode);
+            // 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.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`));
+                process.exitCode = 1;
+                return;
+            }
         }
         else {
             // background mode

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

@@ -101,7 +101,8 @@ export async function stopDaemon(port = PROXY_PORT) {
     return killByPort(port);
 }
 // ─── Helpers ──────────────────────────────────────────────────────────────────
-async function waitForHealth(port, timeoutMs) {
+/** Poll the proxy's health endpoint until it answers or the budget runs out. */
+export async function waitForHealth(port, timeoutMs) {
     const start = Date.now();
     while (Date.now() - start < timeoutMs) {
         try {
@@ -125,34 +126,80 @@ async function waitForDeath(pid, timeoutMs) {
     }
     return false;
 }
+/**
+ * Terminate whatever holds `port` and wait until it is actually gone.
+ *
+ * The previous implementation returned `true` as soon as SIGTERM was sent, so
+ * `cc-router stop` reported "✓ Proxy process stopped" while the process was
+ * still shutting down. A `start` issued immediately afterwards then raced that
+ * teardown. The PID-based path already waited (`waitForDeath`); this is the
+ * fallback taken when no PID file exists, and it now waits too.
+ */
+export async function killPortAndWait(port, deps, timeoutMs = 5_000) {
+    const pids = await deps.listPids(port);
+    if (pids.length === 0)
+        return false;
+    for (const pid of pids)
+        deps.kill(pid, "SIGTERM");
+    const deadline = deps.now() + timeoutMs;
+    const anyAlive = () => pids.some(pid => deps.isAlive(pid));
+    while (anyAlive()) {
+        if (deps.now() >= deadline) {
+            for (const pid of pids) {
+                if (deps.isAlive(pid))
+                    deps.kill(pid, "SIGKILL");
+            }
+            await deps.sleep(POST_KILL_GRACE_MS);
+            return !anyAlive();
+        }
+        await deps.sleep(DEATH_POLL_MS);
+    }
+    return true;
+}
+const DEATH_POLL_MS = 200;
+const POST_KILL_GRACE_MS = 500;
 async function killByPort(port) {
     const { execFile } = await import("child_process");
     const { promisify } = await import("util");
     const execFileAsync = promisify(execFile);
-    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 false;
-            const pid = match.trim().split(/\s+/).at(-1);
-            if (!pid || isNaN(Number(pid)))
-                return false;
-            await execFileAsync("taskkill", ["/PID", pid, "/F"]);
-            return true;
-        }
-        else {
-            const { stdout } = await execFileAsync("lsof", ["-ti", `:${port}`]);
-            const pids = stdout.trim().split("\n").filter(Boolean);
-            if (pids.length === 0)
-                return false;
-            for (const p of pids) {
-                await execFileAsync("kill", ["-TERM", p]);
+    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];
             }
-            return true;
+            const { stdout } = await execFileAsync("lsof", ["-ti", `:${p}`]);
+            return stdout.trim().split("\n").filter(Boolean).map(Number).filter(n => !Number.isNaN(n));
         }
+        catch {
+            return [];
+        }
+    };
+    try {
+        return await killPortAndWait(port, {
+            listPids,
+            // Windows has no signals: taskkill /F is the only lever, so both the
+            // graceful and forced step map onto it.
+            kill: (pid, signal) => {
+                if (isWindows()) {
+                    void execFileAsync("taskkill", ["/PID", String(pid), "/F"]).catch(() => { });
+                    return;
+                }
+                try {
+                    process.kill(pid, signal);
+                }
+                catch { /* already gone */ }
+            },
+            isAlive: isProcessAlive,
+            sleep,
+            now: Date.now,
+        });
     }
     catch {
         return false;

package/dist/daemon/pid.js

@@ -1,6 +1,20 @@
 import { existsSync, readFileSync, writeFileSync, unlinkSync } from "fs";
 import { PID_PATH, PROXY_PORT } from "../config/paths.js";
 import { ensureConfigDir } from "../config/manager.js";
+/**
+ * Whether this process owns the PID file — i.e. its lifetime is what `cc-router
+ * stop` should act on.
+ *
+ * Both the background daemon (`CC_ROUTER_DAEMON`) and the OS service manager
+ * (`CC_ROUTER_SERVICE`, set by the LaunchAgent/systemd unit) qualify. A service
+ * instance used to leave no PID file, so `stop` fell through to killing by
+ * port, which does not wait for the process to exit. A plain `--foreground` run
+ * in a terminal owns nothing: it is the user's to Ctrl+C, and writing its PID
+ * would let `stop` target the wrong process.
+ */
+export function managesPidFile(env = process.env) {
+    return env["CC_ROUTER_DAEMON"] === "1" || env["CC_ROUTER_SERVICE"] === "1";
+}
 /** Write the current process PID to the PID file. */
 export function writePid(pid) {
     try {

package/dist/daemon/service.js

@@ -93,6 +93,60 @@ ${envVars}
 </plist>
 `;
 }
+const TEARDOWN_POLL_MS = 200;
+const TEARDOWN_TIMEOUT_MS = 10_000;
+/**
+ * Load a LaunchAgent that may have just been booted out.
+ *
+ * `launchctl bootout` returns as soon as launchd accepts the request, not once
+ * the job is gone. Bootstrapping the same label during that window fails with
+ * "Bootstrap failed: 5: Input/output error" — and the legacy `load` fallback
+ * fails the same way, so retrying through it does not help. That is what made
+ * `cc-router start` need a second invocation after a restart: the first one
+ * raced launchd's teardown, warned, and left nothing running.
+ *
+ * So: poll until launchd no longer knows the label, then bootstrap, retrying
+ * until a shared deadline because launchd can still reject briefly after the
+ * job disappears from `print`.
+ */
+export async function bootstrapAfterTeardown(opts) {
+    const { uid, label, plistPath, run, sleep, now } = opts;
+    const deadline = now() + (opts.timeoutMs ?? TEARDOWN_TIMEOUT_MS);
+    // Phase 1 — wait for launchd to forget the old job.
+    for (;;) {
+        let stillLoaded;
+        try {
+            await run(["print", `gui/${uid}/${label}`]);
+            stillLoaded = true;
+        }
+        catch {
+            stillLoaded = false; // `print` fails once the label is gone
+        }
+        if (!stillLoaded)
+            break;
+        if (now() >= deadline)
+            return false;
+        await sleep(TEARDOWN_POLL_MS);
+    }
+    // Phase 2 — bootstrap, retrying while launchd finishes releasing the label.
+    for (;;) {
+        try {
+            await run(["bootstrap", `gui/${uid}`, plistPath]);
+            return true;
+        }
+        catch {
+            if (now() >= deadline)
+                return false;
+            await sleep(TEARDOWN_POLL_MS);
+        }
+    }
+}
+const launchctlRun = async (args) => {
+    await execFileAsync("launchctl", args);
+};
+function sleepMs(ms) {
+    return new Promise(r => setTimeout(r, ms));
+}
 async function installMacOS(serverMode) {
     // Ensure LaunchAgents dir exists
     const launchAgentsDir = dirname(LAUNCHD_PLIST);
@@ -103,12 +157,17 @@ async function installMacOS(serverMode) {
         await launchctlUnload();
     }
     writeFileSync(LAUNCHD_PLIST, buildPlist(serverMode), "utf-8");
-    // Load — try modern `bootstrap` first, fallback to legacy `load`
     const uid = String(process.getuid?.() ?? 501);
-    try {
-        await execFileAsync("launchctl", ["bootstrap", `gui/${uid}`, LAUNCHD_PLIST]);
-    }
-    catch {
+    const loaded = await bootstrapAfterTeardown({
+        uid,
+        label: LAUNCHD_LABEL,
+        plistPath: LAUNCHD_PLIST,
+        run: launchctlRun,
+        sleep: sleepMs,
+        now: Date.now,
+    });
+    if (!loaded) {
+        // Last resort for hosts where `bootstrap` is unavailable rather than busy.
         try {
             await execFileAsync("launchctl", ["load", LAUNCHD_PLIST]);
         }

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/proxy/account-patch.js

@@ -1,3 +1,4 @@
+import { isValidAccountId } from "./account-rename.js";
 import { clampPercent } from "./types.js";
 /**
  * Validate a `PATCH /cc-router/accounts/:id` request body. Shared between the
@@ -7,6 +8,15 @@ import { clampPercent } from "./types.js";
  */
 export function validateAccountPatchBody(body) {
     const patch = {};
+    if (body.id !== undefined) {
+        if (!isValidAccountId(body.id)) {
+            return { ok: false, error: "id must be 1-64 characters: alphanumeric start, then letters, digits, dots, underscores, or dashes" };
+        }
+        if (body.enabled !== undefined || body.sessionLimitPercent !== undefined || body.weeklyLimitPercent !== undefined) {
+            return { ok: false, error: "id (rename) cannot be combined with other fields" };
+        }
+        patch.id = body.id;
+    }
     if (body.enabled !== undefined) {
         if (typeof body.enabled !== "boolean") {
             return { ok: false, error: "enabled must be boolean" };

package/dist/proxy/account-rename.js

@@ -0,0 +1,48 @@
+/**
+ * Renaming an account changes the key that routing state hangs off: the
+ * pool's in-flight counters and the session router's sticky bindings are
+ * both id-keyed, so a rename is a transaction over pool + router + disk —
+ * not a field write. Mirrors account-deletion.ts in shape: the provider
+ * branches in server.ts supply their pool/router/persist as ports, and the
+ * CLI shares the id rules from here.
+ */
+/**
+ * An account id ends up in URL paths (`/cc-router/accounts/:id`), fixed-width
+ * dashboard columns, and accounts.json — allow one conservative shape
+ * everywhere: alphanumeric start, then dots/underscores/dashes, 64 max.
+ */
+const ACCOUNT_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+export function isValidAccountId(value) {
+    return typeof value === "string" && ACCOUNT_ID_RE.test(value);
+}
+export class AccountRenameConflictError extends Error {
+    constructor(id) {
+        super(`An account named "${id}" already exists`);
+        this.name = "AccountRenameConflictError";
+    }
+}
+/**
+ * Rename an account atomically with respect to disk: runtime state is only
+ * left renamed if persistence succeeded, otherwise it is renamed back so
+ * memory keeps matching accounts.json. `takenIds` must cover every live id
+ * across ALL providers — the two pools share one id namespace (one URL
+ * space, one accounts.json).
+ */
+export function renameAccountTransaction(oldId, newId, takenIds, ports) {
+    if (newId === oldId)
+        return "renamed";
+    if (takenIds.has(newId))
+        throw new AccountRenameConflictError(newId);
+    if (!ports.rename(oldId, newId))
+        return "not_found";
+    ports.renameSessions(oldId, newId);
+    try {
+        ports.persist();
+    }
+    catch (error) {
+        ports.rename(newId, oldId);
+        ports.renameSessions(newId, oldId);
+        throw error;
+    }
+    return "renamed";
+}

package/dist/proxy/anthropic-routing.js

@@ -2,6 +2,21 @@ import { acquireRequestRoute } from "./lease-lifecycle.js";
 import { normalizeSessionId } from "./session-router.js";
 import { EmptyPoolError, NoEligibleAccountError } from "./token-pool.js";
 const SESSION_HEADER = "x-claude-code-session-id";
+/**
+ * Classify which Anthropic-shaped client sent a request, for the activity log.
+ *
+ * Mirrors the precedence the direct Claude proxy path applies: a Claude Code
+ * session header wins, an `x-api-key` means Claude Desktop, anything else is a
+ * raw API caller. Shared so a `/v1/messages` request that cross-routes to an
+ * OpenAI backend is still labelled by the client that sent it.
+ */
+export function detectAnthropicClientSource(headers) {
+    if (headers[SESSION_HEADER] !== undefined)
+        return "cli";
+    if (headers["x-api-key"] !== undefined)
+        return "desktop";
+    return "api";
+}
 /** Extract exactly one native HTTP session header field without joined duplicates. */
 export function extractClaudeSessionId(request) {
     const distinct = request.headersDistinct;

package/dist/proxy/messages-cross-route.js

@@ -9,7 +9,7 @@ import { terminalResponsePayload, usageFromTerminalEvent, usageFromResponseBody,
 import { extractAnthropicRouteContext } from "./request-model.js";
 import { stats, applyCodexUsage } from "./stats.js";
 import { extractCodexSessionKey } from "./openai-routing.js";
-import { sendAnthropicNoEligibleResponse } from "./anthropic-routing.js";
+import { sendAnthropicNoEligibleResponse, detectAnthropicClientSource } from "./anthropic-routing.js";
 import { mirrorUpstreamHeaders, runOpenAIIngress, } from "./openai-ingress.js";
 const MESSAGES_ENVELOPE = {
     wrap: (type, message) => ({ type: "error", error: { type, message } }),
@@ -348,6 +348,10 @@ export function mountMessagesCrossProviderRoute(app, opts) {
             sessionKey: extractCodexSessionKey(req, req.body),
             requestedModel: route.upstreamModel,
             path: "/v1/messages",
+            method: req.method,
+            // A Claude-shaped client that happens to route to an OpenAI backend is
+            // still that client — classify it the way the Claude path does.
+            source: detectAnthropicClientSource(req.headers),
             openAIRouter: opts.openAIRouter,
             openAIPool: opts.openAIPool,
             prepareOpenAIAccount,

package/dist/proxy/openai-ingress.js

@@ -298,6 +298,8 @@ export async function runOpenAIIngress(opts) {
         model: requestedModel,
         type: "route",
         path,
+        ...(opts.method !== undefined ? { method: opts.method } : {}),
+        ...(opts.source !== undefined ? { source: opts.source } : {}),
         details,
     };
     let finalStatus = upstream.status;

package/dist/proxy/responses-server.js

@@ -124,6 +124,9 @@ export function mountResponsesRoutes(app, opts) {
             sessionKey: extractCodexSessionKey(req, req.body),
             requestedModel: route.upstreamModel,
             path: "/v1/responses",
+            method: req.method,
+            // Only the Codex CLI speaks the Responses API to this proxy.
+            source: "codex",
             openAIRouter: opts.openAIRouter,
             openAIPool: opts.openAIPool,
             prepareOpenAIAccount,

package/dist/proxy/server.js

@@ -5,14 +5,15 @@ import { timingSafeEqual } from "crypto";
 import { TokenPool } from "./token-pool.js";
 import { needsRefresh, refreshAccountIfCurrent, saveAccounts, startRefreshLoop } from "./token-refresher.js";
 import { loadAccounts, loadOpenAIAccounts, saveOpenAIAccountsToPath, accountsFileExists, readAccountsFromPath, readConfig, writeConfig, getProxyRequestTimeoutMs, migrateLegacyAccountProviders, setProviderAccountsEnabled } from "../config/manager.js";
-import { checkForUpdate, performUpdate, restartSelf, printUpdateBanner } from "../utils/self-update.js";
+import { checkForUpdate, performUpdate, restartSelf, printUpdateBanner, getCurrentVersion } from "../utils/self-update.js";
 import { trackEvent, startHeartbeat } from "../utils/telemetry.js";
 import { loadTelemetryState } from "../config/telemetry.js";
 import { logRoute, logError, logStartup } from "./logger.js";
 import { createLocalRoutingErrorLog, stats } from "./stats.js";
 import { PROXY_PORT, LITELLM_URL, ACCOUNTS_PATH } from "../config/paths.js";
-import { writePid, removePid } from "../daemon/pid.js";
+import { writePid, removePid, managesPidFile } from "../daemon/pid.js";
 import { applyOpenAIAccountPatch, validateAccountPatchBody } from "./account-patch.js";
+import { AccountRenameConflictError, renameAccountTransaction } from "./account-rename.js";
 import { hasPendingCredentialWrite, markOpenAICredentialsPersisted, prepareOpenAIAccountForRequest, refreshAndPersistOpenAIAccount, startOpenAIRefreshLoop, } from "../providers/openai/token-refresher.js";
 import { createOpenAIAccount } from "../providers/openai/account-state.js";
 import { OpenAITokenPool } from "../providers/openai/token-pool.js";
@@ -487,6 +488,11 @@ export async function startServer(opts = {}) {
         }
         res.json({
             status,
+            // The version of the code this daemon actually runs — not what is
+            // installed on disk. A service manager can keep an old build alive
+            // long after an upgrade (launchd pins the versioned pnpm store path
+            // in its plist), and without this field no client can tell.
+            version: getCurrentVersion(),
             mode,
             target,
             operational: createOperationalStatus({
@@ -627,6 +633,54 @@ export async function startServer(opts = {}) {
             return;
         }
         const patch = validation.patch;
+        // A rename is a transaction over pool + session router + disk, not a
+        // field write (see account-rename.ts) — validation already guarantees it
+        // arrives alone. The two pools share one id namespace, so uniqueness is
+        // checked across both regardless of which provider owns the account.
+        if (patch.id !== undefined) {
+            const newId = patch.id;
+            const takenIds = new Set([
+                ...pool.getAll().map(a => a.id),
+                ...openAIAccounts.map(a => a.id),
+            ]);
+            const inAnthropic = pool.findById(id) !== null;
+            if (!inAnthropic && !openAIAccounts.some(a => a.id === id)) {
+                res.status(404).json({ error: `Account "${id}" not found` });
+                return;
+            }
+            try {
+                renameAccountTransaction(id, newId, takenIds, inAnthropic
+                    ? {
+                        rename: (oldId, nextId) => pool.renameAccount(oldId, nextId) !== null,
+                        renameSessions: (oldId, nextId) => { sessionRouter.renameAccount(oldId, nextId); },
+                        persist: () => saveAccounts(pool.getAll()),
+                    }
+                    : {
+                        rename: (oldId, nextId) => openAIPool.renameAccount(oldId, nextId) !== null,
+                        renameSessions: (oldId, nextId) => { openAIRouter.renameAccount(oldId, nextId); },
+                        persist: () => persistOpenAIAccounts(openAIAccounts),
+                    });
+            }
+            catch (err) {
+                if (err instanceof AccountRenameConflictError) {
+                    res.status(409).json({ error: err.message });
+                    return;
+                }
+                const message = err instanceof Error ? err.message : String(err);
+                logError("accounts", 0, `Failed to persist accounts.json: ${message}`);
+                res.status(500).json({ error: `Failed to persist accounts.json: ${message}` });
+                return;
+            }
+            if (inAnthropic) {
+                const account = pool.findById(newId);
+                res.json({ account: publicAnthropicAccountView(account, createRoutingMetricsResolver()(account.id)) });
+            }
+            else {
+                const account = openAIAccounts.find(a => a.id === newId);
+                res.json({ account: publicOpenAIAccountView(account, resolveOpenAIRouting(account.id)) });
+            }
+            return;
+        }
         // Snapshot the previous values so we can roll back on persistence failure
         const existing = pool.findById(id);
         if (existing) {
@@ -1126,7 +1180,7 @@ export async function startServer(opts = {}) {
         console.log(chalk.yellow("\nShutting down — saving tokens..."));
         usageRefresher.stop();
         saveAccounts(pool.getAll());
-        if (process.env["CC_ROUTER_DAEMON"] === "1") {
+        if (managesPidFile()) {
             removePid();
         }
         process.exit(0);
@@ -1193,7 +1247,7 @@ export async function startServer(opts = {}) {
     }
     app.listen(port, host, () => {
         // Write PID for daemon/service process management
-        if (process.env["CC_ROUTER_DAEMON"] === "1") {
+        if (managesPidFile()) {
             writePid(process.pid);
         }
         const totalAccountCount = accounts.length + openAIAccounts.length;

package/dist/proxy/session-router.js

@@ -92,6 +92,29 @@ export class SessionRouter {
         }
         return removed;
     }
+    /**
+     * Re-point every binding (and the aggregate session count) at an account's
+     * new id after a rename. Without this the sticky re-acquire looks the old
+     * id up in the pool, finds nothing, and silently fails the session over —
+     * a rename must not break prompt-cache affinity. Returns bindings moved.
+     */
+    renameAccount(oldId, newId) {
+        if (newId === oldId)
+            return 0;
+        let moved = 0;
+        for (const binding of this.bindings.values()) {
+            if (binding.accountId !== oldId)
+                continue;
+            binding.accountId = newId;
+            moved++;
+        }
+        const count = this.activeSessionCounts.get(oldId);
+        if (count !== undefined) {
+            this.activeSessionCounts.delete(oldId);
+            this.activeSessionCounts.set(newId, count);
+        }
+        return moved;
+    }
     getActiveSessionCount(accountId) {
         this.sweepExpiredBindings(this.now());
         return this.getRawActiveSessionCount(accountId);

package/dist/proxy/token-pool.js

@@ -599,6 +599,28 @@ export class TokenPool {
         }
         return a;
     }
+    /**
+     * 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 never have been
+     * incremented, leaving the old key stuck at its count forever. 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.
+     */
+    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;
+    }
     /**
      * Append a new account built from a persisted AccountRecord.
      * Rejects duplicates by id — callers should pre-check with findById().

package/dist/ui/Dashboard.js

@@ -3,9 +3,14 @@ import React, { useState, useEffect, useCallback, useRef } from "react";
 import { Box, Text, useInput, useApp } from "ink";
 import { createAccountsApi } from "./accountsApi.js";
 import { createModelsApi } from "./modelsApi.js";
+import { getCurrentVersion } from "../utils/self-update.js";
 const POLL_INTERVAL_MS = 2_000;
 const LOG_VISIBLE = 20;
 const MODEL_VISIBLE_ROWS = 16;
+const DASHBOARD_VERSION = getCurrentVersion();
+// Distinguishes "this machine's daemon" (restartable from this shell) from a
+// remote router the dashboard is merely pointed at.
+const LOCAL_TARGET_RE = /^https?:\/\/(localhost|127\.0\.0\.1|\[::1\])(:\d+)?$/i;
 const EMPTY_RL = {
     status: "unknown", fiveHourUtil: 0, fiveHourReset: 0,
     sevenDayUtil: 0, sevenDayReset: 0, claim: "", plan: "",
@@ -102,6 +107,45 @@ function codexWindowLabel(windowMinutes, fallback) {
     }
     return fallback;
 }
+/**
+ * Whether a reported window carries real data.
+ *
+ * Codex sends absent windows as all-zero placeholders rather than omitting the
+ * field, so a truthiness check treats "no such window" as a window with no
+ * duration — which then renders under a guessed label.
+ */
+function hasWindow(window) {
+    return window !== undefined && window.windowMinutes > 0;
+}
+/**
+ * The default (`codex`) bucket's windows, each labelled from its own duration.
+ *
+ * These used to be read positionally — `primary` as the 5h window, `secondary`
+ * as the weekly one. Codex reports the weekly window in `primary` and leaves
+ * `secondary` empty, so an account at 100% of its weekly quota displayed as
+ * "5h 100%" beside a "weekly 0%" bar that was really the empty slot. The reset
+ * countdown gave it away: a 5h window cannot reset five days out.
+ */
+export function getCodexDefaultWindows(codex) {
+    const bucket = codex?.buckets.find(b => b.limitId === "codex");
+    if (!bucket)
+        return [];
+    const windows = [];
+    for (const [window, fallback] of [
+        [bucket.primary, "5h"],
+        [bucket.secondary, "weekly"],
+    ]) {
+        if (!hasWindow(window))
+            continue;
+        windows.push({
+            label: codexWindowLabel(window.windowMinutes, fallback),
+            utilization: window.utilization,
+            resetAt: window.resetAt,
+            kind: window.windowMinutes >= 10_080 ? "weekly" : "session",
+        });
+    }
+    return windows;
+}
 /** Named Codex metered buckets as compact capacity rows (default bucket renders as bars). */
 export function getCodexCapacityRows(codex, globalCooldownUntilMs, now = Date.now()) {
     const rows = [];
@@ -110,10 +154,14 @@ export function getCodexCapacityRows(codex, globalCooldownUntilMs, now = Date.no
             continue;
         const cooling = bucket.cooldownUntilMs > now;
         const windows = [];
-        if (bucket.primary) {
+        // A zero-width window is Codex's placeholder for "this bucket has no such
+        // window", not a real one — it arrives as an all-zero object rather than
+        // being omitted. Rendering it duplicated the bucket, and both rows carried
+        // the same label because codexWindowLabel(0) falls through to its fallback.
+        if (hasWindow(bucket.primary)) {
             windows.push({ label: codexWindowLabel(bucket.primary.windowMinutes, "5h"), ...bucket.primary });
         }
-        if (bucket.secondary) {
+        if (hasWindow(bucket.secondary)) {
             windows.push({ label: codexWindowLabel(bucket.secondary.windowMinutes, "weekly"), ...bucket.secondary });
         }
         for (const window of windows) {
@@ -165,6 +213,24 @@ export function isCodexLimited(codex) {
         return false;
     return (defaultBucket.primary?.utilization ?? 0) >= 1 || (defaultBucket.secondary?.utilization ?? 0) >= 1;
 }
+/**
+ * First visible row of a scrolling list window that follows its selection.
+ *
+ * The window stays where it is while the selection moves inside it, and
+ * shifts just far enough to contain the selection when it crosses an edge —
+ * one row per one-row step, but any distance when the selection jumps (it is
+ * timestamp-anchored, so a burst of new entries can move it many rows at
+ * once). A stale `scrollTop` from a longer list clamps back into range.
+ */
+export function followScrollWindow(scrollTop, selectedIndex, total, visible) {
+    const maxTop = Math.max(0, total - visible);
+    let top = Math.min(Math.max(0, scrollTop), maxTop);
+    if (selectedIndex < top)
+        top = selectedIndex;
+    else if (selectedIndex > top + visible - 1)
+        top = selectedIndex - visible + 1;
+    return Math.min(Math.max(0, top), maxTop);
+}
 export function Dashboard({ port, baseUrl, authToken, onIntent }) {
     const { exit } = useApp();
     const [data, setData] = useState(null);
@@ -242,13 +308,18 @@ function LiveDashboard({ data, port, baseUrl, lastUpdate, api, modelsApi, onInte
     const selectedLogIndex = selectedTs !== null
         ? Math.max(0, logs.findIndex(l => l.ts === selectedTs))
         : 0;
+    // First visible activity row. The stored position only moves on navigation;
+    // the derived value re-clamps every render because the selection is
+    // timestamp-anchored — new entries arriving between keypresses can push the
+    // selected row out of the stored window, and it must stay visible anyway.
+    const [logScrollTop, setLogScrollTop] = useState(0);
+    const logWindowTop = followScrollWindow(logScrollTop, selectedLogIndex, logs.length, LOG_VISIBLE);
     // Selected account by id
     const [selectedAccountId, setSelectedAccountId] = useState(null);
     const selectedAccountIndex = selectedAccountId !== null
         ? Math.max(0, data.accounts.findIndex(a => a.id === selectedAccountId))
         : 0;
     const selectedAccount = data.accounts[selectedAccountIndex] ?? null;
-    const selectedAccountIsAnthropic = selectedAccount?.provider !== "openai_subscription";
     const [modelsStatus, setModelsStatus] = useState(null);
     const [selectedModelId, setSelectedModelId] = useState(null);
     const modelRows = modelsStatus?.models ?? [];
@@ -287,13 +358,14 @@ function LiveDashboard({ data, port, baseUrl, lastUpdate, api, modelsApi, onInte
         return s || "unknown error";
     };
     // ── Async helpers (fire-and-forget with error → banner) ──────────────────
+    // Provider-agnostic: `PATCH /cc-router/accounts/:id` applies `enabled` to
+    // OpenAI accounts through the same transaction contract as Claude ones, and
+    // drops their sticky bindings on disable. The cap keys below never had a
+    // provider check; this one was left behind after the endpoint gained OpenAI
+    // support, so the dashboard was refusing an operation the server had.
     const doToggleEnabled = useCallback(async () => {
         if (!selectedAccount)
             return;
-        if (selectedAccount.provider === "openai_subscription") {
-            showBanner("OpenAI accounts are managed from the CLI", "yellow");
-            return;
-        }
         const newValue = !(selectedAccount.enabled !== false);
         try {
             await api.patch(selectedAccount.id, { enabled: newValue });
@@ -336,10 +408,6 @@ function LiveDashboard({ data, port, baseUrl, lastUpdate, api, modelsApi, onInte
     const doDelete = useCallback(async () => {
         if (!selectedAccount)
             return;
-        if (selectedAccount.provider === "openai_subscription") {
-            showBanner("Use cc-router accounts remove for OpenAI accounts", "yellow");
-            return;
-        }
         try {
             await api.remove(selectedAccount.id);
             showBanner(`Removed ${selectedAccount.id}`, "yellow");
@@ -455,10 +523,12 @@ function LiveDashboard({ data, port, baseUrl, lastUpdate, api, modelsApi, onInte
             if (key.upArrow) {
                 const next = Math.max(0, selectedLogIndex - 1);
                 setSelectedTs(logs[next]?.ts ?? null);
+                setLogScrollTop(followScrollWindow(logWindowTop, next, logs.length, LOG_VISIBLE));
             }
             if (key.downArrow) {
                 const next = Math.min(logs.length - 1, selectedLogIndex + 1);
                 setSelectedTs(logs[next]?.ts ?? null);
+                setLogScrollTop(followScrollWindow(logWindowTop, next, logs.length, LOG_VISIBLE));
             }
         }
         if (focus === "accounts") {
@@ -493,11 +563,12 @@ function LiveDashboard({ data, port, baseUrl, lastUpdate, api, modelsApi, onInte
                 setEditBuffer("");
                 return;
             }
+            // Also provider-agnostic: `DELETE /cc-router/accounts/:id` removes an
+            // OpenAI account through `deleteOpenAIAccountTransaction`, which is the
+            // same path `cc-router accounts remove` reaches. Sending the operator to
+            // the CLI for something the dashboard can do was left over from before
+            // that existed.
             if (input === "d") {
-                if (!selectedAccountIsAnthropic) {
-                    showBanner("Use cc-router accounts remove for OpenAI accounts", "yellow");
-                    return;
-                }
                 setMode("confirmDelete");
                 return;
             }
@@ -540,10 +611,15 @@ function LiveDashboard({ data, port, baseUrl, lastUpdate, api, modelsApi, onInte
         }
     });
     const selectedLog = logs[selectedLogIndex] ?? null;
-    const visibleLogs = logs.slice(0, LOG_VISIBLE);
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, color: "cyan", children: " CC-Router " }), _jsx(Text, { color: "gray", children: "\u00B7 " }), _jsx(Text, { color: "green", children: data.mode }), _jsxs(Text, { color: "gray", children: [" \u2192 ", data.target, "  \u00B7 "] }), _jsxs(Text, { children: ["up ", formatUptime(data.uptime)] }), _jsxs(Text, { color: "gray", children: ["  \u00B7  updated ", updatedAgo, "s ago  \u00B7  [q] quit"] })] }), _jsx(Box, { marginTop: 1 }), data.operational && (_jsxs(_Fragment, { children: [_jsx(OperationsPanel, { operational: data.operational, baseUrl: baseUrl, focus: focus }), _jsx(Box, { marginTop: 1 })] })), (focus === "models" || modelsStatus) && (_jsxs(_Fragment, { children: [_jsx(ModelsPanel, { status: modelsStatus, selectedIndex: selectedModelIndex, focused: focus === "models" }), _jsx(Box, { marginTop: 1 })] })), _jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsxs(Text, { bold: true, children: [" ACCOUNTS  ", _jsxs(Text, { color: healthyCount === data.accounts.length ? "green" : "yellow", children: [healthyCount, "/", data.accounts.length, " healthy"] })] }), _jsx(Text, { color: "gray", children: "   " }), _jsx(Text, { color: focus === "accounts" ? "white" : "gray", children: "[Tab] focus  [e] toggle  [a] Claude all  [o] OpenAI all  [w] 7d cap  [s] 5h cap  [n] add  [d] delete" })] }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: data.accounts.map((a, i) => (_jsx(AccountRow, { account: a, selected: focus === "accounts" && i === selectedAccountIndex }, a.id))) })] }), mode === "editWeekly" && selectedAccount && (_jsxs(Box, { marginTop: 1, paddingLeft: 2, children: [_jsx(Text, { color: "cyan", children: "Set 7d cap for " }), _jsx(Text, { color: "white", bold: true, children: selectedAccount.id }), _jsx(Text, { color: "cyan", children: " (0\u2013100%): " }), _jsx(Text, { color: "white", bold: true, children: editBuffer }), _jsx(Text, { color: "gray", children: "\u2588  [Enter] save  [Esc] cancel" })] })), mode === "editSession" && selectedAccount && (_jsxs(Box, { marginTop: 1, paddingLeft: 2, children: [_jsx(Text, { color: "cyan", children: "Set 5h cap for " }), _jsx(Text, { color: "white", bold: true, children: selectedAccount.id }), _jsx(Text, { color: "cyan", children: " (0\u2013100%): " }), _jsx(Text, { color: "white", bold: true, children: editBuffer }), _jsx(Text, { color: "gray", children: "\u2588  [Enter] save  [Esc] cancel" })] })), mode === "confirmDelete" && selectedAccount && (_jsx(Box, { marginTop: 1, paddingLeft: 2, children: _jsxs(Text, { color: "red", bold: true, children: ["Delete \"", selectedAccount.id, "\"?  [y] yes  [n/Esc] cancel"] }) })), banner && (_jsx(Box, { marginTop: 1, paddingLeft: 2, children: _jsxs(Text, { color: banner.color, children: [" ", banner.text] }) })), _jsx(Box, { marginTop: 1 }), _jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, children: " TOTALS  " }), _jsx(Text, { children: "requests " }), _jsx(Text, { color: "cyan", children: data.totalRequests }), _jsx(Text, { color: "gray", children: "  \u00B7  " }), _jsx(Text, { children: "errors " }), _jsx(Text, { color: data.totalErrors > 0 ? "red" : "green", children: data.totalErrors }), _jsx(Text, { color: "gray", children: "  \u00B7  " }), _jsx(Text, { children: "refreshes " }), _jsx(Text, { color: "yellow", children: data.totalRefreshes }), _jsx(CacheHealthBadge, { read: data.totalCacheReadTokens, created: data.totalCacheCreationTokens, input: data.totalInputTokens })] }), _jsx(TokenSummary, { cacheRead: data.totalCacheReadTokens, cacheCreated: data.totalCacheCreationTokens, uncached: data.totalInputTokens, output: data.totalOutputTokens ?? 0 })] }), _jsx(Box, { marginTop: 1 }), _jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: " RECENT ACTIVITY" }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: visibleLogs.length === 0
+    const visibleLogs = logs.slice(logWindowTop, logWindowTop + LOG_VISIBLE);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, color: "cyan", children: " CC-Router " }), _jsx(Text, { color: "gray", children: "\u00B7 " }), _jsx(Text, { color: "green", children: data.mode }), _jsxs(Text, { color: "gray", children: [" \u2192 ", data.target, "  \u00B7 "] }), _jsxs(Text, { children: ["up ", formatUptime(data.uptime)] }), _jsxs(Text, { color: "gray", children: ["  \u00B7  updated ", updatedAgo, "s ago  \u00B7  [q] quit"] })] }), data.version !== DASHBOARD_VERSION && (_jsxs(Box, { children: [_jsx(Text, { bold: true, color: "yellow", children: " \u26A0 VERSION MISMATCH  " }), _jsxs(Text, { color: "yellow", children: [data.version !== undefined
+                                ? `daemon v${data.version}`
+                                : "daemon version unreported (older build)", ` · dashboard v${DASHBOARD_VERSION}`] }), LOCAL_TARGET_RE.test(baseUrl) ? (_jsxs(_Fragment, { children: [_jsx(Text, { color: "gray", children: "  \u2014  restart: " }), _jsx(Text, { color: "cyan", children: "cc-router stop --keep-config && cc-router start" })] })) : (
+                    // A remote router can only be restarted where it runs; printing a
+                    // local restart command here would never clear the banner.
+                    _jsxs(Text, { color: "gray", children: ["  \u2014  update and restart the daemon on ", baseUrl] }))] })), _jsx(Box, { marginTop: 1 }), data.operational && (_jsxs(_Fragment, { children: [_jsx(OperationsPanel, { operational: data.operational, baseUrl: baseUrl, focus: focus }), _jsx(Box, { marginTop: 1 })] })), (focus === "models" || modelsStatus) && (_jsxs(_Fragment, { children: [_jsx(ModelsPanel, { status: modelsStatus, selectedIndex: selectedModelIndex, focused: focus === "models" }), _jsx(Box, { marginTop: 1 })] })), _jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsxs(Text, { bold: true, children: [" ACCOUNTS  ", _jsxs(Text, { color: healthyCount === data.accounts.length ? "green" : "yellow", children: [healthyCount, "/", data.accounts.length, " healthy"] })] }), _jsx(Text, { color: "gray", children: "   " }), _jsx(Text, { color: focus === "accounts" ? "white" : "gray", children: "[Tab] focus  [e] toggle  [a] Claude all  [o] OpenAI all  [w] 7d cap  [s] 5h cap  [n] add  [d] delete" })] }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: data.accounts.map((a, i) => (_jsx(AccountRow, { account: a, selected: focus === "accounts" && i === selectedAccountIndex }, a.id))) })] }), mode === "editWeekly" && selectedAccount && (_jsxs(Box, { marginTop: 1, paddingLeft: 2, children: [_jsx(Text, { color: "cyan", children: "Set 7d cap for " }), _jsx(Text, { color: "white", bold: true, children: selectedAccount.id }), _jsx(Text, { color: "cyan", children: " (0\u2013100%): " }), _jsx(Text, { color: "white", bold: true, children: editBuffer }), _jsx(Text, { color: "gray", children: "\u2588  [Enter] save  [Esc] cancel" })] })), mode === "editSession" && selectedAccount && (_jsxs(Box, { marginTop: 1, paddingLeft: 2, children: [_jsx(Text, { color: "cyan", children: "Set 5h cap for " }), _jsx(Text, { color: "white", bold: true, children: selectedAccount.id }), _jsx(Text, { color: "cyan", children: " (0\u2013100%): " }), _jsx(Text, { color: "white", bold: true, children: editBuffer }), _jsx(Text, { color: "gray", children: "\u2588  [Enter] save  [Esc] cancel" })] })), mode === "confirmDelete" && selectedAccount && (_jsx(Box, { marginTop: 1, paddingLeft: 2, children: _jsxs(Text, { color: "red", bold: true, children: ["Delete \"", selectedAccount.id, "\"?  [y] yes  [n/Esc] cancel"] }) })), banner && (_jsx(Box, { marginTop: 1, paddingLeft: 2, children: _jsxs(Text, { color: banner.color, children: [" ", banner.text] }) })), _jsx(Box, { marginTop: 1 }), _jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, children: " TOTALS  " }), _jsx(Text, { children: "requests " }), _jsx(Text, { color: "cyan", children: data.totalRequests }), _jsx(Text, { color: "gray", children: "  \u00B7  " }), _jsx(Text, { children: "errors " }), _jsx(Text, { color: data.totalErrors > 0 ? "red" : "green", children: data.totalErrors }), _jsx(Text, { color: "gray", children: "  \u00B7  " }), _jsx(Text, { children: "refreshes " }), _jsx(Text, { color: "yellow", children: data.totalRefreshes }), _jsx(CacheHealthBadge, { read: data.totalCacheReadTokens, created: data.totalCacheCreationTokens, input: data.totalInputTokens })] }), _jsx(TokenSummary, { cacheRead: data.totalCacheReadTokens, cacheCreated: data.totalCacheCreationTokens, uncached: data.totalInputTokens, output: data.totalOutputTokens ?? 0 })] }), _jsx(Box, { marginTop: 1 }), _jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: " RECENT ACTIVITY" }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: visibleLogs.length === 0
                             ? _jsx(Text, { color: "gray", children: "  No activity yet" })
-                            : visibleLogs.map((log, i) => (_jsx(LogRow, { log: log, selected: focus === "logs" && i === selectedLogIndex }, `${log.ts}-${i}`))) })] }), focus === "logs" && selectedLog && (_jsxs(_Fragment, { children: [_jsx(Box, { marginTop: 1 }), _jsx(DetailPanel, { log: selectedLog })] }))] }));
+                            : visibleLogs.map((log, i) => (_jsx(LogRow, { log: log, selected: focus === "logs" && logWindowTop + i === selectedLogIndex }, `${log.ts}-${i}`))) })] }), focus === "logs" && selectedLog && (_jsxs(_Fragment, { children: [_jsx(Box, { marginTop: 1 }), _jsx(DetailPanel, { log: selectedLog })] }))] }));
 }
 function OperationsPanel({ operational, baseUrl, focus }) {
     const authLabel = operational.auth.required ? "protected" : "open";
@@ -599,7 +675,7 @@ function AccountRow({ account: a, selected }) {
     const globalCapacity = getGlobalCapacityView(rl);
     const isOpenAI = a.provider === "openai_subscription";
     const codex = a.codexRateLimits;
-    const codexDefaultBucket = codex?.buckets.find(bucket => bucket.limitId === "codex");
+    const codexDefaultWindows = getCodexDefaultWindows(codex);
     const capacityRows = isOpenAI
         ? getCodexCapacityRows(a.codexRateLimits, a.globalCooldownUntilMs)
         : getAccountCapacityRows(a);
@@ -632,10 +708,10 @@ function AccountRow({ account: a, selected }) {
                 ? codex.credits.balance
                 : codex.credits.hasCredits ? "yes" : "no"
         : undefined;
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: selected ? "cyan" : undefined, children: pointer }), _jsxs(Text, { color: dotColor, children: [" ", dot, " "] }), _jsx(Text, { color: nameColor, dimColor: isDisabled, children: a.id.slice(0, 20).padEnd(20) }), _jsx(Text, { color: statusColor, children: statusLabel }), providerTag && _jsx(Text, { color: isOpenAI ? "cyan" : "magenta", children: providerTag.padEnd(10) }), !providerTag && _jsx(Text, { children: "".padEnd(10) }), _jsx(Text, { color: "gray", children: " req " }), _jsx(Text, { color: "white", children: String(a.requestCount).padStart(5) }), _jsx(Text, { color: "gray", children: "  err " }), _jsx(Text, { color: a.errorCount > 0 ? "red" : "gray", children: String(a.errorCount).padStart(3) }), _jsx(Text, { color: "gray", children: "  tok " }), _jsx(Text, { color: expiryColor, children: expiryLabel.padEnd(8) }), _jsx(Text, { color: "gray", children: "  last " }), _jsx(Text, { color: "gray", children: formatAgo(a.lastUsedMs) }), _jsxs(Text, { color: "gray", children: ["  ", a.activeSessions ?? 0, " active / ", a.inFlightRequests ?? 0, " streams"] }), capsHint && _jsx(Text, { color: "yellow", children: capsHint }), a.credentialsPendingWrite && (
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: selected ? "cyan" : undefined, children: pointer }), _jsxs(Text, { color: dotColor, children: [" ", dot, " "] }), _jsx(Text, { color: nameColor, dimColor: isDisabled, children: a.id.slice(0, 20).padEnd(21) }), _jsx(Text, { color: statusColor, children: statusLabel }), providerTag && _jsx(Text, { color: isOpenAI ? "cyan" : "magenta", children: providerTag.padEnd(10) }), !providerTag && _jsx(Text, { children: "".padEnd(10) }), _jsx(Text, { color: "gray", children: " req " }), _jsx(Text, { color: "white", children: String(a.requestCount).padStart(5) }), _jsx(Text, { color: "gray", children: "  err " }), _jsx(Text, { color: a.errorCount > 0 ? "red" : "gray", children: String(a.errorCount).padStart(3) }), _jsx(Text, { color: "gray", children: "  tok " }), _jsx(Text, { color: expiryColor, children: expiryLabel.padEnd(8) }), _jsx(Text, { color: "gray", children: "  last " }), _jsx(Text, { color: "gray", children: formatAgo(a.lastUsedMs) }), _jsxs(Text, { color: "gray", children: ["  ", a.activeSessions ?? 0, " active / ", a.inFlightRequests ?? 0, " streams"] }), capsHint && _jsx(Text, { color: "yellow", children: capsHint }), a.credentialsPendingWrite && (
                     // The account still works — its rotated token is live in memory — but a
                     // restart before the pending write lands would need a re-login.
-                    _jsx(Text, { color: "yellow", children: "  creds unsaved" }))] }), (rl.lastUpdated > 0 || usage) && (_jsxs(Box, { paddingLeft: 4, children: [_jsx(UtilBar, { label: "5h", util: globalCapacity.fiveHour.utilization, resetTs: globalCapacity.fiveHour.resetAt, isActive: rl.claim === "five_hour", cap: s5 }), _jsx(Text, { children: "   " }), _jsx(UtilBar, { label: "7d all-model", util: globalCapacity.sevenDay.utilization, resetTs: globalCapacity.sevenDay.resetAt, isActive: rl.claim === "seven_day", cap: w7 }), usage && _jsx(Text, { color: globalCapacity.usageFetchStatus === "fresh" ? "gray" : "yellow", children: `  usage ${globalCapacity.usageFetchStatus} ${usage.fetchedAt > 0 ? formatAgo(usage.fetchedAt) : ""}` })] })), isOpenAI && codexDefaultBucket && (codexDefaultBucket.primary || codexDefaultBucket.secondary) && (_jsxs(Box, { paddingLeft: 4, children: [_jsx(UtilBar, { label: "5h", util: codexDefaultBucket.primary?.utilization ?? 0, resetTs: codexDefaultBucket.primary?.resetAt ?? 0, isActive: false, cap: s5 }), _jsx(Text, { children: "   " }), _jsx(UtilBar, { label: "weekly", util: codexDefaultBucket.secondary?.utilization ?? 0, resetTs: codexDefaultBucket.secondary?.resetAt ?? 0, isActive: false, cap: w7 }), creditsLabel !== undefined && _jsx(Text, { color: "gray", children: `  credits ${creditsLabel}` })] })), capacityRows.map((row, index) => (_jsxs(Box, { paddingLeft: 4, children: [_jsxs(Text, { color: row.color, children: [" ", row.label] }), _jsxs(Text, { color: "gray", children: [" \u00B7 ", row.state] }), row.utilization !== undefined && _jsx(Text, { color: row.color, children: ` ${Math.round(row.utilization * 100)}%` }), row.resetAt !== undefined && row.resetAt > 0 && (_jsxs(Text, { color: "gray", children: [" ", `↻${formatResetIn(row.resetAt)}`] }))] }, `${row.label}-${index}`)))] }));
+                    _jsx(Text, { color: "yellow", children: "  creds unsaved" }))] }), (rl.lastUpdated > 0 || usage) && (_jsxs(Box, { paddingLeft: 4, children: [_jsx(UtilBar, { label: "5h", util: globalCapacity.fiveHour.utilization, resetTs: globalCapacity.fiveHour.resetAt, isActive: rl.claim === "five_hour", cap: s5 }), _jsx(Text, { children: "   " }), _jsx(UtilBar, { label: "7d all-model", util: globalCapacity.sevenDay.utilization, resetTs: globalCapacity.sevenDay.resetAt, isActive: rl.claim === "seven_day", cap: w7 }), usage && _jsx(Text, { color: globalCapacity.usageFetchStatus === "fresh" ? "gray" : "yellow", children: `  usage ${globalCapacity.usageFetchStatus} ${usage.fetchedAt > 0 ? formatAgo(usage.fetchedAt) : ""}` })] })), isOpenAI && codexDefaultWindows.length > 0 && (_jsxs(Box, { paddingLeft: 4, children: [codexDefaultWindows.map((window, index) => (_jsxs(React.Fragment, { children: [index > 0 && _jsx(Text, { children: "   " }), _jsx(UtilBar, { label: window.label, util: window.utilization, resetTs: window.resetAt, isActive: false, cap: window.kind === "weekly" ? w7 : s5 })] }, window.label))), creditsLabel !== undefined && _jsx(Text, { color: "gray", children: `  credits ${creditsLabel}` })] })), capacityRows.map((row, index) => (_jsxs(Box, { paddingLeft: 4, children: [_jsxs(Text, { color: row.color, children: [" ", row.label] }), _jsxs(Text, { color: "gray", children: [" \u00B7 ", row.state] }), row.utilization !== undefined && _jsx(Text, { color: row.color, children: ` ${Math.round(row.utilization * 100)}%` }), row.resetAt !== undefined && row.resetAt > 0 && (_jsxs(Text, { color: "gray", children: [" ", `↻${formatResetIn(row.resetAt)}`] }))] }, `${row.label}-${index}`)))] }));
 }
 // ─── Utilization bar ─────────────────────────────────────────────────────────
 function UtilBar({ label, util, resetTs, isActive, cap }) {
@@ -680,10 +756,12 @@ function LogRow({ log, selected }) {
     const sourceLabel = log.source === "cli" ? "cli"
         : log.source === "desktop" ? "dsk"
             : log.source === "api" ? "api"
-                : "   ";
+                : log.source === "codex" ? "cdx"
+                    : "   ";
     const sourceColor = log.source === "cli" ? "blue"
         : log.source === "desktop" ? "magenta"
-            : "gray";
+            : log.source === "codex" ? "cyan"
+                : "gray";
     // Per-request token stats
     const inputTok = (log.cacheReadTokens ?? 0) + (log.cacheCreationTokens ?? 0) + (log.inputTokens ?? 0);
     const outputTok = log.outputTokens ?? 0;
@@ -759,6 +837,8 @@ function sourceFullLabel(source) {
         return "Claude Code";
     if (source === "desktop")
         return "Claude Desktop";
+    if (source === "codex")
+        return "Codex CLI";
     if (source === "api")
         return "API";
     return "—";

package/package.json

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