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

package/CHANGELOG.md

@@ -8,7 +8,57 @@ This project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
-Nothing yet.
+### 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-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/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/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

@@ -11,7 +11,7 @@ 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 { hasPendingCredentialWrite, markOpenAICredentialsPersisted, prepareOpenAIAccountForRequest, refreshAndPersistOpenAIAccount, startOpenAIRefreshLoop, } from "../providers/openai/token-refresher.js";
 import { createOpenAIAccount } from "../providers/openai/account-state.js";
@@ -1126,7 +1126,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 +1193,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/ui/Dashboard.js

@@ -102,6 +102,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 +149,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) {
@@ -248,7 +291,6 @@ function LiveDashboard({ data, port, baseUrl, lastUpdate, api, modelsApi, onInte
         ? 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 +329,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 +379,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");
@@ -493,11 +532,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;
             }
@@ -599,7 +639,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 +672,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 +720,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 +801,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.2",
   "description": "Cache-aware session router for Claude Max OAuth tokens — use multiple Claude Max accounts with Claude Code",
   "type": "module",
   "bin": {