@timo972/cc-router 0.12.0 → 0.12.1-rc.1

package/dist/proxy/server.js

@@ -1,10 +1,13 @@
+import { consumeCodexResetCredit } from "../providers/openai/usage-reset.js";
+import { createUsageResetHandler } from "./account-usage-reset.js";
 import express from "express";
 import { createProxyMiddleware } from "http-proxy-middleware";
 import { ServerResponse } from "http";
 import { timingSafeEqual } from "crypto";
 import { TokenPool } from "./token-pool.js";
-import { needsRefresh, refreshAccountIfCurrent, saveAccounts, startRefreshLoop } from "./token-refresher.js";
+import { needsRefresh, refreshAccountIfCurrent, refreshAccountsOnce, saveAccounts, startRefreshLoop } from "./token-refresher.js";
 import { loadAccounts, loadOpenAIAccounts, saveOpenAIAccountsToPath, accountsFileExists, readAccountsFromPath, readConfig, writeConfig, getAutoFailoverEnabled, getProxyRequestTimeoutMs, migrateLegacyAccountProviders, setProviderAccountsEnabled, upsertAccountRecord, removeAccountRecordById } from "../config/manager.js";
+import { createRefreshAllRunner, describeRefreshAll, refreshAllAccounts } from "./pool-refresh.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";
@@ -17,7 +20,7 @@ import { loadGrokHealthSnapshots } from "../providers/xai/overview.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 { hasPendingCredentialWrite, markOpenAICredentialsPersisted, prepareOpenAIAccountForRequest, refreshOpenAIAccountsOnce, refreshAndPersistOpenAIAccount, startOpenAIRefreshLoop, } from "../providers/openai/token-refresher.js";
 import { createOpenAIAccount } from "../providers/openai/account-state.js";
 import { OpenAITokenPool } from "../providers/openai/token-pool.js";
 import { DEFAULT_CODEX_LIMIT_ID } from "../providers/openai/usage.js";
@@ -61,6 +64,7 @@ export function createOperationalStatus(opts) {
             health: "/cc-router/health",
             accounts: "/cc-router/accounts",
             allowance: "/cc-router/allowance",
+            refresh: "/cc-router/refresh",
             messages: "/v1/messages",
             responses: "/v1/responses",
             models: "/v1/models",
@@ -222,7 +226,7 @@ function publicOpenAIAccountView(a, routing) {
         enabled: a.enabled !== false,
         sessionLimitPercent: a.sessionLimitPercent,
         weeklyLimitPercent: a.weeklyLimitPercent,
-        healthy: a.enabled !== false && a.healthy && expiresInMs > 0,
+        healthy: a.enabled !== false && a.healthy && a.authState !== "quarantined" && expiresInMs > 0,
         busy: routing.metrics.coolingDown,
         cooldownUntilMs: routing.metrics.cooldownUntilMs ?? 0,
         globalCooldownUntilMs: routing.cooldowns.globalUntilMs,
@@ -235,6 +239,8 @@ function publicOpenAIAccountView(a, routing) {
         lastRefreshMs: a.lastRefresh,
         codexRateLimits: publicCodexRateLimits(a, routing.cooldowns),
         ...(hasPendingCredentialWrite(a) ? { credentialsPendingWrite: true } : {}),
+        ...(a.authState === "quarantined" ? { authState: "quarantined" } : {}),
+        ...(a.authFailure ? { authFailure: a.authFailure } : {}),
     };
 }
 function publicCodexRateLimits(a, cooldowns) {
@@ -532,12 +538,72 @@ export async function startServer(opts = {}) {
         const views = createHealthAccountViews(pool.getAll(), openAIAccounts, resolveRoutingMetrics, createOpenAIRoutingResolver(), loadGrokHealthSnapshots());
         res.json(createAllowanceView(views, Date.now()));
     });
+    // ─── Manual reload (authenticated) ────────────────────────────────────────
+    // The dashboard's "reload everything" key. Gives the operator what a
+    // restart would — swept cooldowns, due/quarantined tokens re-tried, every
+    // account's usage re-fetched — without dropping in-flight requests or
+    // sticky sessions. Each provider contributes its own hooks; the route
+    // itself knows nothing about OAuth or usage formats.
+    const runRefreshAll = createRefreshAllRunner(() => {
+        const onError = (provider, error) => {
+            const message = error instanceof Error ? error.message : String(error);
+            logError(provider, 0, `manual refresh: ${message}`);
+        };
+        return refreshAllAccounts([
+            {
+                provider: "anthropic",
+                getAll: () => pool.getAll(),
+                refreshTokens: async () => {
+                    let failed = 0;
+                    await refreshAccountsOnce(pool.getAll(), { onError: error => { failed++; onError("anthropic", error); } });
+                    return { failed };
+                },
+                refreshUsage: account => usageRefresher.refreshNow(account),
+            },
+            {
+                provider: "openai",
+                getAll: () => openAIAccounts,
+                refreshTokens: () => refreshOpenAIAccountsOnce(openAIAccounts, persistOpenAIAccounts, {
+                    onError: error => onError("openai", error),
+                }),
+                refreshUsage: account => openAIUsageRefresher.refreshNow(account),
+            },
+        ], {
+            sweepCooldowns: () => {
+                pool.sweepExpiredCooldowns();
+                openAIPool.sweepExpiredCooldowns();
+            },
+            onError,
+        });
+    });
+    app.post("/cc-router/refresh", async (_req, res) => {
+        let summary;
+        try {
+            summary = await runRefreshAll();
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            logError("refresh", 0, `manual refresh failed: ${message}`);
+            res.status(500).json({ error: `Refresh failed: ${message}` });
+            return;
+        }
+        const details = `manual refresh — ${describeRefreshAll(summary)}`;
+        stats.addLog({ ts: Date.now(), accountId: "proxy", model: "-", type: "refresh", details });
+        res.json({ refresh: summary });
+    });
     // ─── Account management endpoints (authenticated) ─────────────────────────
     // These are mounted BEFORE the /v1/* proxy middleware so they don't get
     // forwarded to Anthropic. express.json() is scoped to this sub-router so
     // the SSE streaming on /v1/* is never touched (see comment at /v1 handler).
     const accountsRouter = express.Router();
     accountsRouter.use(express.json({ limit: "32kb" }));
+    accountsRouter.post("/:id/reset-usage", createUsageResetHandler({
+        findAccount: id => openAIAccounts.find(account => account.id === id),
+        prepare: account => prepareOpenAIAccountForRequest(account, openAIAccounts, persistOpenAIAccounts),
+        consume: consumeCodexResetCredit,
+        captureReset: account => openAIPool.captureUsageReset(account),
+        refresh: account => openAIUsageRefresher.refreshAfterCurrent(account),
+    }));
     // Shape returned to clients — NEVER includes access/refresh tokens.
     accountsRouter.get("/", (_req, res) => {
         const resolveRoutingMetrics = createRoutingMetricsResolver();
@@ -989,6 +1055,7 @@ export async function startServer(opts = {}) {
         prepareOpenAIAccount: (account) => prepareOpenAIAccountForRequest(account, openAIAccounts, persistOpenAIAccounts),
         modelRouting,
         onUpstreamAuthFailure: onOpenAIUpstreamAuthFailure,
+        timeoutMs: proxyRequestTimeoutMs,
         ...upstreamAttempts,
     });
     mountMessagesCrossProviderRoute(app, {
@@ -997,6 +1064,7 @@ export async function startServer(opts = {}) {
         prepareOpenAIAccount: (account) => prepareOpenAIAccountForRequest(account, openAIAccounts, persistOpenAIAccounts),
         modelRouting,
         onUpstreamAuthFailure: onOpenAIUpstreamAuthFailure,
+        timeoutMs: proxyRequestTimeoutMs,
         ...upstreamAttempts,
     });
     // Shared between the retrying /v1/messages route and the generic /v1 chain

package/dist/proxy/transport-diagnostics.js

@@ -0,0 +1,32 @@
+import { randomUUID } from "node:crypto";
+const SAFE_CODE = /^[A-Za-z0-9_.:-]{1,48}$/;
+const SAFE_CORRELATION = /^[A-Za-z0-9-]{1,48}$/;
+export function createCorrelationId() {
+    return `oai-${randomUUID().slice(0, 8)}`;
+}
+export function safeCauseCode(error) {
+    let cause = error instanceof Error ? error.cause : undefined;
+    for (let depth = 0; depth < 3 && typeof cause === "object" && cause !== null; depth++) {
+        const code = cause.code;
+        if (typeof code === "string" && SAFE_CODE.test(code))
+            return code;
+        cause = cause.cause;
+    }
+    return undefined;
+}
+export function formatTransportDiagnostic(diagnostic) {
+    const correlationId = SAFE_CORRELATION.test(diagnostic.correlationId)
+        ? diagnostic.correlationId
+        : "invalid";
+    const fields = [
+        `correlation=${correlationId}`,
+        `operation=${diagnostic.operation}`,
+    ];
+    if (diagnostic.status !== undefined && Number.isInteger(diagnostic.status)) {
+        fields.push(`status=${diagnostic.status}`);
+    }
+    if (diagnostic.causeCode !== undefined && SAFE_CODE.test(diagnostic.causeCode)) {
+        fields.push(`cause=${diagnostic.causeCode}`);
+    }
+    return fields.join(" ");
+}

package/dist/proxy/transport-timing.js

@@ -0,0 +1,153 @@
+export function createHeaderDeadline(timeoutMs, parent) {
+    if (!timeoutMs || timeoutMs <= 0) {
+        return { signal: parent, dispose() { } };
+    }
+    const controller = new AbortController();
+    let timer = setTimeout(() => {
+        controller.abort(new DOMException("upstream headers timed out", "TimeoutError"));
+    }, timeoutMs);
+    const onParentAbort = () => controller.abort(parent?.reason);
+    if (parent?.aborted) {
+        onParentAbort();
+    }
+    else {
+        parent?.addEventListener("abort", onParentAbort, { once: true });
+    }
+    return {
+        signal: controller.signal,
+        dispose() {
+            if (timer)
+                clearTimeout(timer);
+            timer = undefined;
+            parent?.removeEventListener("abort", onParentAbort);
+        },
+    };
+}
+/**
+ * Wrap a body with a timeout for each upstream read.
+ *
+ * The zero high-water mark is deliberate. A positive high-water mark lets the
+ * Web Streams implementation prefetch the next chunk as soon as the previous
+ * one is delivered. When the HTTP response is waiting for downstream drain,
+ * that prefetched read would run the upstream idle timer and could time out an
+ * otherwise healthy stream solely because its client was slow.
+ */
+export function withStreamIdleTimeout(body, idleMs, parent) {
+    if (!body)
+        return null;
+    const timeoutEnabled = idleMs !== undefined && idleMs > 0;
+    if (!timeoutEnabled && !parent)
+        return body;
+    const reader = body.getReader();
+    let timer;
+    let closed = false;
+    let controllerRef;
+    const clearIdleTimer = () => {
+        if (timer)
+            clearTimeout(timer);
+        timer = undefined;
+    };
+    const releaseReader = () => {
+        try {
+            reader.releaseLock();
+        }
+        catch {
+            // A cancellation can briefly leave read() pending. reader.cancel()
+            // settles it before trying this again in its finally callback.
+        }
+    };
+    const finish = (release = true) => {
+        if (closed)
+            return;
+        closed = true;
+        clearIdleTimer();
+        parent?.removeEventListener("abort", onAbort);
+        if (release)
+            releaseReader();
+    };
+    const fail = (error) => {
+        if (closed)
+            return;
+        finish(false);
+        controllerRef?.error(error);
+        void reader.cancel(error).catch(() => { }).finally(releaseReader);
+    };
+    const onAbort = () => {
+        fail(parent?.reason ?? new DOMException("aborted", "AbortError"));
+    };
+    const startIdleTimer = () => {
+        if (!timeoutEnabled)
+            return;
+        clearIdleTimer();
+        timer = setTimeout(() => {
+            fail(new DOMException("upstream stream idle timeout", "TimeoutError"));
+        }, idleMs);
+    };
+    return new ReadableStream({
+        start(controller) {
+            controllerRef = controller;
+            if (parent?.aborted)
+                onAbort();
+            else
+                parent?.addEventListener("abort", onAbort, { once: true });
+        },
+        async pull(controller) {
+            if (closed)
+                return;
+            startIdleTimer();
+            try {
+                const next = await reader.read();
+                clearIdleTimer();
+                if (closed)
+                    return;
+                if (next.done) {
+                    finish();
+                    controller.close();
+                    return;
+                }
+                controller.enqueue(next.value);
+            }
+            catch (error) {
+                if (closed)
+                    return;
+                finish();
+                controller.error(error);
+            }
+        },
+        async cancel(reason) {
+            if (closed)
+                return;
+            finish(false);
+            try {
+                await reader.cancel(reason);
+            }
+            finally {
+                releaseReader();
+            }
+        },
+    }, { highWaterMark: 0 });
+}
+/** Resolve only when an HTTP response can accept another write. Every losing
+ * listener is removed, including the error/close path. */
+export function waitForWritable(res) {
+    if (res.destroyed)
+        return Promise.resolve(false);
+    return new Promise(resolve => {
+        let done = false;
+        const finish = (value) => {
+            if (done)
+                return;
+            done = true;
+            res.removeListener("drain", drain);
+            res.removeListener("close", closed);
+            res.removeListener("error", errored);
+            resolve(value);
+        };
+        const drain = () => finish(true);
+        const closed = () => finish(false);
+        const errored = () => finish(false);
+        res.once("drain", drain);
+        res.once("close", closed);
+        res.once("error", errored);
+    });
+}

package/dist/ui/Dashboard.js

@@ -1,4 +1,5 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { randomUUID } from "node:crypto";
 import React, { useState, useEffect, useCallback, useRef } from "react";
 import { Box, Text, useInput, useApp, useStdout, measureElement } from "ink";
 import { createAccountsApi } from "./accountsApi.js";
@@ -7,6 +8,9 @@ import { getCurrentVersion } from "../utils/self-update.js";
 import { readClaudeRouting, readCodexRouting, setClaudeRouting, setCodexRouting, } from "../utils/cli-routing.js";
 import { mergeGrokIntoHealth, loadGrokHealthSnapshotsWithSubscription } from "../providers/xai/overview.js";
 const POLL_INTERVAL_MS = 2_000;
+/** Progress banner for the manual reload; replaced by the result banner, so
+ *  only the failure case (client gave up) ever lets it expire. */
+const REFRESH_ALL_BANNER_MS = 120_000;
 /** Grok's plan/code-access rarely change; refresh far slower than the 2s poll. */
 const GROK_SUBSCRIPTION_INTERVAL_MS = 60_000;
 /** Most activity rows the dashboard will show — the list shrinks below this
@@ -528,6 +532,9 @@ export function Dashboard({ port, baseUrl, authToken, onIntent }) {
     const [connectError, setConnectError] = useState(null);
     const [lastUpdate, setLastUpdate] = useState(0);
     const [retryCount, setRetryCount] = useState(0);
+    // LiveDashboard unmounts on a health-poll failure. Redemption ownership and
+    // retry IDs must survive that transition, not just a change in focus.
+    const resetSession = useRef({ inFlight: false, pendingIds: new Map() });
     const resolvedBase = baseUrl
         ? baseUrl.replace(/\/+$/, "")
         : `http://localhost:${port}`;
@@ -543,22 +550,22 @@ export function Dashboard({ port, baseUrl, authToken, onIntent }) {
     // /v1/user round-trip every tick. Undefined until the first fetch lands, at
     // which point `mergeGrokIntoHealth` falls back to its access-token tier.
     const grokSnapshotsRef = useRef(undefined);
-    useEffect(() => {
-        let cancelled = false;
-        const refresh = async () => {
-            try {
-                const snapshots = await loadGrokHealthSnapshotsWithSubscription();
-                if (!cancelled)
-                    grokSnapshotsRef.current = snapshots;
-            }
-            catch {
-                // Keep the last known snapshots; the poll degrades to the tier fallback.
-            }
-        };
-        refresh();
-        const timer = setInterval(refresh, GROK_SUBSCRIPTION_INTERVAL_MS);
-        return () => { cancelled = true; clearInterval(timer); };
+    const refreshGrokSnapshots = useCallback(async () => {
+        try {
+            grokSnapshotsRef.current = await loadGrokHealthSnapshotsWithSubscription();
+        }
+        catch {
+            // Keep the last known snapshots; the poll degrades to the tier fallback.
+        }
     }, []);
+    useEffect(() => {
+        refreshGrokSnapshots();
+        const timer = setInterval(refreshGrokSnapshots, GROK_SUBSCRIPTION_INTERVAL_MS);
+        return () => { clearInterval(timer); };
+    }, [refreshGrokSnapshots]);
+    // The manual reload key re-runs the same poll immediately so the freshly
+    // fetched usage shows up without waiting for the next 2s tick.
+    const pollRef = useRef(async () => { });
     useEffect(() => {
         let cancelled = false;
         const healthUrl = `${resolvedBase}/cc-router/health`;
@@ -590,24 +597,29 @@ export function Dashboard({ port, baseUrl, authToken, onIntent }) {
                 setRetryCount(n => n + 1);
             }
         };
+        pollRef.current = poll;
         poll();
         const timer = setInterval(poll, POLL_INTERVAL_MS);
         return () => { cancelled = true; clearInterval(timer); };
     }, [resolvedBase, authToken]);
+    const refreshLocalViews = useCallback(async () => {
+        await refreshGrokSnapshots();
+        await pollRef.current();
+    }, [refreshGrokSnapshots]);
     if (connectError) {
         return _jsx(ErrorScreen, { error: connectError, port: port, retries: retryCount });
     }
     if (!data) {
         return (_jsx(Box, { flexDirection: "column", marginTop: 1, children: _jsxs(Text, { color: "yellow", children: ["\u280B Connecting to ", resolvedBase, "..."] }) }));
     }
-    return (_jsx(LiveDashboard, { data: data, port: port, baseUrl: resolvedBase, lastUpdate: lastUpdate, api: api, modelsApi: modelsApi, onIntent: onIntent }));
+    return (_jsx(LiveDashboard, { data: data, port: port, baseUrl: resolvedBase, lastUpdate: lastUpdate, api: api, modelsApi: modelsApi, onIntent: onIntent, onRefreshAll: refreshLocalViews, resetSession: resetSession.current }));
 }
 // ─── Error screen ─────────────────────────────────────────────────────────────
 function ErrorScreen({ error, port, retries }) {
     return (_jsxs(Box, { flexDirection: "column", marginY: 1, marginX: 2, children: [_jsxs(Text, { color: "red", bold: true, children: ["\u2717 ", error] }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { color: "yellow", children: "Is the proxy running? Start it with:" }), _jsx(Text, { color: "cyan", children: "  cc-router start" })] }), _jsxs(Box, { marginTop: 1, children: [_jsxs(Text, { color: "gray", children: ["Retrying every ", POLL_INTERVAL_MS / 1000, "s"] }), retries > 0 && _jsxs(Text, { color: "gray", children: ["  (attempt ", retries, ")"] }), _jsx(Text, { color: "gray", children: "  \u00B7  [q] quit" })] })] }));
 }
 // ─── Live dashboard ───────────────────────────────────────────────────────────
-function LiveDashboard({ data, port, baseUrl, lastUpdate, api, modelsApi, onIntent, }) {
+function LiveDashboard({ data, port, baseUrl, lastUpdate, api, modelsApi, onIntent, onRefreshAll, resetSession, }) {
     const [cliRouting, setCliRouting] = useState(() => ({
         claude: readClaudeRouting(),
         codex: readCodexRouting(),
@@ -633,6 +645,7 @@ function LiveDashboard({ data, port, baseUrl, lastUpdate, api, modelsApi, onInte
     // ── Focus / mode ──────────────────────────────────────────────────────────
     const [focus, setFocus] = useState("logs");
     const [mode, setMode] = useState("view");
+    const [resetTarget, setResetTarget] = useState(null);
     // Compact ("zen") view: hides TOTALS + RECENT ACTIVITY so the account list
     // gets the whole vertical budget — the fix for a short terminal starving a
     // long fleet (e.g. showing 1 of 11 accounts). Toggled with [z], view-only,
@@ -770,14 +783,14 @@ function LiveDashboard({ data, port, baseUrl, lastUpdate, api, modelsApi, onInte
     // setBanner can fire on an unmounted component after `n` exits Ink.
     const [banner, setBanner] = useState(null);
     const bannerTimerRef = useRef(null);
-    const showBanner = useCallback((text, color) => {
+    const showBanner = useCallback((text, color, durationMs = 4_000) => {
         if (bannerTimerRef.current)
             clearTimeout(bannerTimerRef.current);
         setBanner({ text, color });
         bannerTimerRef.current = setTimeout(() => {
             setBanner(null);
             bannerTimerRef.current = null;
-        }, 4_000);
+        }, durationMs);
     }, []);
     useEffect(() => () => {
         if (bannerTimerRef.current)
@@ -872,6 +885,47 @@ function LiveDashboard({ data, port, baseUrl, lastUpdate, api, modelsApi, onInte
             showBanner(`Models error: ${errMsg(err)}`, "red");
         }
     }, [modelsApi, showBanner]);
+    // ── Reload everything ────────────────────────────────────────────────────
+    // One key for "make it look like I just restarted the router": the server
+    // sweeps cooldowns, re-tries due/quarantined tokens and re-fetches every
+    // account's usage; the dashboard then re-reads Grok, CLI routing, the
+    // model list (if already loaded) and polls health right away.
+    const refreshAllInFlightRef = useRef(false);
+    const doRefreshAll = useCallback(async () => {
+        if (refreshAllInFlightRef.current) {
+            showBanner("Reload already running…", "gray");
+            return;
+        }
+        refreshAllInFlightRef.current = true;
+        // Stays up until the result banner replaces it: a reload with several
+        // slow providers can outlive the default banner lifetime.
+        showBanner("Reloading accounts, usage and models…", "cyan", REFRESH_ALL_BANNER_MS);
+        try {
+            const result = await api.refreshAll();
+            refreshCliRouting();
+            if (modelsStatus) {
+                try {
+                    const status = await modelsApi.list();
+                    setModelsStatus(status);
+                }
+                catch {
+                    // The account reload succeeded; a stale model list is not worth a red banner.
+                }
+            }
+            await onRefreshAll?.();
+            const problems = [
+                result.usageFailed > 0 ? `${result.usageFailed} usage fetch failed` : "",
+                result.tokenRefreshFailed > 0 ? `${result.tokenRefreshFailed} token refresh failed` : "",
+            ].filter(Boolean);
+            showBanner(`Reloaded ${result.accounts} accounts — usage fresh for ${result.usageRefreshed}${problems.length ? `, ${problems.join(", ")}` : ""}`, problems.length ? "yellow" : "green");
+        }
+        catch (err) {
+            showBanner(`Reload error: ${errMsg(err)}`, "red");
+        }
+        finally {
+            refreshAllInFlightRef.current = false;
+        }
+    }, [api, modelsApi, modelsStatus, onRefreshAll, refreshCliRouting, showBanner]);
     const doToggleCli = useCallback((target) => {
         const current = target === "claude" ? cliRouting.claude.enabled : cliRouting.codex.enabled;
         const result = target === "claude"
@@ -910,6 +964,37 @@ function LiveDashboard({ data, port, baseUrl, lastUpdate, api, modelsApi, onInte
             showBanner(`Models error: ${errMsg(err)}`, "red");
         }
     }, [modelsApi, selectedModel, showBanner]);
+    const doResetUsage = useCallback(async (id) => {
+        if (resetSession.inFlight)
+            return;
+        resetSession.inFlight = true;
+        const requestId = resetSession.pendingIds.get(id) ?? randomUUID();
+        resetSession.pendingIds.set(id, requestId);
+        showBanner(`Redeeming usage reset for ${id}…`, "yellow", REFRESH_ALL_BANNER_MS);
+        try {
+            const result = await api.resetUsage(id, requestId);
+            resetSession.pendingIds.delete(id);
+            const messages = {
+                reset: `Usage reset redeemed for ${id}`,
+                already_redeemed: `Usage reset already redeemed for ${id}`,
+                nothing_to_reset: `Nothing to reset for ${id}`,
+                no_credit: `No reset credits available for ${id}`,
+            };
+            showBanner(messages[result.code] + (result.usageRefreshed ? "" : " — usage refresh failed; reload with R"), result.usageRefreshed && (result.code === "reset" || result.code === "already_redeemed") ? "green" : "yellow");
+            // Failure to poll the dashboard must not turn a confirmed spend into an
+            // unknown outcome or encourage another redemption.
+            try {
+                await onRefreshAll?.();
+            }
+            catch { /* the regular poll will retry */ }
+        }
+        catch {
+            showBanner(`Reset outcome unknown for ${id}; Ctrl+R retries the same redemption (keep dashboard open)`, "red");
+        }
+        finally {
+            resetSession.inFlight = false;
+        }
+    }, [api, onRefreshAll, resetSession, showBanner]);
     // ── Keyboard handler ──────────────────────────────────────────────────────
     useInput((input, key) => {
         // ── Text editing mode (w / s) ───────────────────────────────────────
@@ -941,6 +1026,15 @@ function LiveDashboard({ data, port, baseUrl, lastUpdate, api, modelsApi, onInte
             }
             return;
         }
+        if (mode === "confirmReset") {
+            if ((input === "y" || input === "Y") && resetTarget)
+                void doResetUsage(resetTarget);
+            else
+                showBanner("Reset cancelled", "gray");
+            setResetTarget(null);
+            setMode("view");
+            return;
+        }
         // ── Confirm delete (y/n) ────────────────────────────────────────────
         if (mode === "confirmDelete") {
             if (input === "y" || input === "Y") {
@@ -970,6 +1064,31 @@ function LiveDashboard({ data, port, baseUrl, lastUpdate, api, modelsApi, onInte
             exit();
             return;
         }
+        // Intercept Ctrl+R before model refresh so it only acts on account focus.
+        // Ink exposes the standard DC2 control character as input r + key.ctrl.
+        if (input === "r" && key.ctrl) {
+            if (focus !== "accounts" || !selectedAccount)
+                return;
+            if (resetSession.inFlight) {
+                showBanner("Reset already running", "yellow");
+                return;
+            }
+            if (selectedAccount.provider !== "openai_subscription") {
+                showBanner("Usage resets are only available for ChatGPT accounts", "yellow");
+                return;
+            }
+            if (!resetSession.pendingIds.has(selectedAccount.id) && (selectedAccount.codexRateLimits?.resetCredits?.available ?? 0) <= 0) {
+                showBanner("No reset credits available", "yellow");
+                return;
+            }
+            setResetTarget(selectedAccount.id);
+            setMode("confirmReset");
+            return;
+        }
+        if (input === "R") {
+            void doRefreshAll();
+            return;
+        }
         if (key.tab) {
             // Compact view hides the activity list, so skip "logs" in the cycle.
             if (compact) {
@@ -1111,7 +1230,7 @@ function LiveDashboard({ data, port, baseUrl, lastUpdate, api, modelsApi, onInte
     });
     const selectedLog = logs[selectedLogIndex] ?? null;
     const visibleLogs = logs.slice(logWindowTop, logWindowTop + logVisible);
-    return (_jsx(Box, { flexDirection: "column", height: frameBound, overflowY: "hidden", children: _jsxs(Box, { flexDirection: "column", flexShrink: 0, ref: contentRef, children: [_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 }), _jsx(Text, { color: "gray", children: "  \u00B7  " }), _jsxs(Text, { children: ["up ", formatUptime(data.uptime)] }), _jsx(Text, { color: "gray", children: "  \u00B7  " }), _jsx(Text, { color: "cyan", children: data.totalRequests }), _jsx(Text, { color: "gray", children: " req  " }), _jsx(Text, { color: data.totalErrors > 0 ? "red" : "green", children: data.totalErrors }), _jsx(Text, { color: "gray", children: " err" }), _jsx(CacheHealthBadge, { read: data.totalCacheReadTokens, created: data.totalCacheCreationTokens, input: data.totalInputTokens }), _jsx(Text, { color: "gray", children: "  \u00B7  [q] quit" })] }), mode === "editWeekly" && selectedAccount && (_jsxs(Box, { 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, { 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, { paddingLeft: 2, children: _jsxs(Text, { color: "red", bold: true, children: ["Delete \"", selectedAccount.id, "\"?  [y] yes  [n/Esc] cancel"] }) })), 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
+    return (_jsx(Box, { flexDirection: "column", height: frameBound, overflowY: "hidden", children: _jsxs(Box, { flexDirection: "column", flexShrink: 0, ref: contentRef, children: [_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 }), _jsx(Text, { color: "gray", children: "  \u00B7  " }), _jsxs(Text, { children: ["up ", formatUptime(data.uptime)] }), _jsx(Text, { color: "gray", children: "  \u00B7  " }), _jsx(Text, { color: "cyan", children: data.totalRequests }), _jsx(Text, { color: "gray", children: " req  " }), _jsx(Text, { color: data.totalErrors > 0 ? "red" : "green", children: data.totalErrors }), _jsx(Text, { color: "gray", children: " err" }), _jsx(CacheHealthBadge, { read: data.totalCacheReadTokens, created: data.totalCacheCreationTokens, input: data.totalInputTokens }), _jsx(Text, { color: "gray", children: "  \u00B7  [q] quit" })] }), mode === "editWeekly" && selectedAccount && (_jsxs(Box, { 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, { 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 === "confirmReset" && resetTarget && (_jsx(Box, { paddingLeft: 2, children: _jsxs(Text, { color: "yellow", bold: true, children: ["Redeem 1 reset for \"", resetTarget, "\"?  [y] yes  [n/Esc] cancel"] }) })), mode === "confirmDelete" && selectedAccount && (_jsx(Box, { paddingLeft: 2, children: _jsxs(Text, { color: "red", bold: true, children: ["Delete \"", selectedAccount.id, "\"?  [y] yes  [n/Esc] cancel"] }) })), 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
@@ -1119,10 +1238,10 @@ function LiveDashboard({ data, port, baseUrl, lastUpdate, api, modelsApi, onInte
                                 _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, cliRouting: cliRouting }), _jsx(Box, { marginTop: 1 })] })), (focus === "models" || modelsStatus) && (_jsxs(_Fragment, { children: [_jsx(ModelsPanel, { status: modelsStatus, selectedIndex: selectedModelIndex, focused: focus === "models", visibleRows: modelsVisible, rowsRef: modelRowsRef }), _jsx(Box, { marginTop: 1 })] })), _jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsxs(Text, { bold: true, children: [" ACCOUNTS  ", _jsxs(Text, { color: healthyCount === orderedAccounts.length ? "green" : "yellow", children: [healthyCount, "/", orderedAccounts.length, " healthy"] }), weeklyFullCount > 0 && _jsx(Text, { color: "red", children: `  ·  ${weeklyFullCount} 7d full` })] }), shownAccounts < orderedAccounts.length && (_jsxs(Text, { color: "gray", children: ["  ·  showing ", accountWindowTop + 1, "\u2013", accountWindowTop + shownAccounts] })), compact && _jsx(Text, { color: "cyan", children: "  ·  compact" })] }), _jsx(Box, { marginTop: 1, flexDirection: "column", ref: accountRowsRef, children: _jsx(AccountGroups, { visible: orderedAccounts.slice(accountWindowTop, accountWindowTop + shownAccounts), fleet: orderedAccounts, windowTop: accountWindowTop, selectedIndex: selectedAccountIndex, focused: focus === "accounts" }) })] }), banner && (_jsx(Box, { marginTop: 1, paddingLeft: 2, children: _jsxs(Text, { color: banner.color, children: [" ", banner.text] }) })), !compact && (_jsxs(_Fragment, { children: [_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 }), _jsx(Text, { bold: true, children: " RECENT ACTIVITY" }), _jsx(Box, { marginTop: 1 })] }))] }), !compact && (_jsx(Box, { flexDirection: "column", ref: logRowsRef, children: visibleLogs.length === 0
                         ? _jsx(Text, { color: "gray", children: "  No activity yet" })
                         : visibleLogs.map((log, i) => (_jsx(LogRow, { log: log, selected: focus === "logs" && logWindowTop + i === selectedLogIndex }, `${log.ts}-${i}`))) })), !compact && focus === "logs" && selectedLog && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginTop: 1 }), _jsx(DetailPanel, { log: selectedLog })] })), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "gray", children: focus === "accounts"
-                            ? " [Tab]  [e] toggle  [a]/[o]/[g] provider  [n] add  [d] delete  [w] 7d  [s] 5h  [z] compact  [q]"
+                            ? " [Tab]  [e] toggle  [a]/[o]/[g] provider  [n] add  [d] delete  [w] 7d  [s] 5h  [Ctrl+R] reset  [R] reload  [z] compact  [q]"
                             : focus === "models"
-                                ? " [Tab]  [m/r] refresh  [c]/[o] default  [Esc] logs  [z] compact  [q]"
-                                : " [Tab]  [m] models  [z] compact  [q] quit" }) })] }) }));
+                                ? " [Tab]  [m/r] refresh  [c]/[o] default  [R] reload all  [Esc] logs  [z] compact  [q]"
+                                : " [Tab]  [m] models  [R] reload  [z] compact  [q] quit" }) })] }) }));
 }
 function OperationsPanel({ operational, baseUrl, focus, cliRouting }) {
     const authLabel = operational.auth.required ? "protected" : "open";