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

package/CHANGELOG.md

@@ -10,6 +10,11 @@ This project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ### Added
 
+- Dashboard `Ctrl+R` confirms redemption of one banked usage-limit reset for
+  the focused ChatGPT account, with duplicate-submission protection and stable
+  retry IDs for uncertain outcomes. No custom Meta key mapping is needed.
+  Account usage is refreshed after redemption.
+
 - Dashboard `[R]` reloads account usage and due tokens without restarting the
   router or dropping active requests and sticky sessions. It also refreshes
   Grok snapshots, CLI routing state, and an already-loaded model list, with

package/README.md

@@ -588,11 +588,30 @@ The dashboard is also a control surface. In local mode it controls the local pro
 | `e` | Enable/disable selected Claude account |
 | `w` / `s` | Change selected Claude account weekly/session cap |
 | `d` | Delete selected Claude account |
+| `Ctrl+R` | Confirm redeeming one banked usage-limit reset for the focused ChatGPT account |
+| `R` | Reload account usage and due credentials without restarting the router |
 | `m` / `r` | Load or refresh discovered provider models |
 | `c` | Toggle Claude Code routing (or set Claude model default when MODELS is focused) |
 | `x` | Toggle Codex CLI routing (proxy stays up) |
 | `o` | Set selected `openai/*` model as OpenAI default |
 
+To redeem a ChatGPT reset, press `Tab` to focus accounts, select the account
+with the arrow keys, then press `Ctrl+R` and confirm with `y` (`n` or `Esc`
+cancels). The `rst` column shows banked reset credits. Accounts with zero or
+unknown credits cannot start a new redemption. This spends a real reset credit;
+it is not the same as refreshing usage with uppercase `R`.
+
+Press **Control + R** (not Command + R or Shift + R). This uses the standard
+terminal Ctrl+R sequence and does not require a custom Meta/Option key mapping.
+
+Redemption targets only that account and refreshes its usage afterward. If the
+network outcome is unknown, keep the dashboard open and retry the shortcut: it
+reuses the same redemption ID instead of spending another credit. Those retry
+IDs are held for the current dashboard session only; after restarting it,
+inspect usage before requesting another reset. A successful redemption with a
+failed usage refresh is reported separately. Confirmed resets plus fresh usage clear only superseded quota cooldowns.
+Overload holds, unreported/exhausted limits, and newer quota signals are preserved.
+
 List and change models without waiting for a package update:
 
 ```bash

package/dist/providers/openai/token-pool.js

@@ -69,8 +69,13 @@ export class OpenAITokenPool {
         // Each cause extends its own horizon, so neither can misrepresent the
         // other's duration in either direction.
         state.globalUntil = Math.max(state.globalUntil, expiry);
-        if (cause === "rate_limit")
+        if (cause === "rate_limit") {
             state.rateLimitedUntil = Math.max(state.rateLimitedUntil, expiry);
+            state.quotaRevision++;
+        }
+        else {
+            state.unavailableUntil = Math.max(state.unavailableUntil, expiry);
+        }
     }
     setBucketCooldownForAccount(account, limitId, durationMs) {
         const expiry = this.proposedExpiry(account, durationMs);
@@ -80,6 +85,7 @@ export class OpenAITokenPool {
         if (!state.bucketUntil.has(limitId))
             this.makeRoomForBucketCooldown(state);
         state.bucketUntil.set(limitId, Math.max(state.bucketUntil.get(limitId) ?? 0, expiry));
+        state.quotaRevision++;
     }
     /**
      * Keep `bucketUntil` bounded before a new limit id is added. Every distinct
@@ -114,6 +120,31 @@ export class OpenAITokenPool {
         if (soonestId !== undefined)
             state.bucketUntil.delete(soonestId);
     }
+    /** Capture before a redemption. Apply only after confirmed redemption and a
+     * fresh post-redemption usage fetch. New quota evidence conservatively fences
+     * the whole reconciliation; unrelated overload holds retain their own expiry. */
+    captureUsageReset(account) {
+        const state = this.cooldowns.get(account);
+        const revision = state?.quotaRevision;
+        return update => {
+            if (!state || this.findById(account.id) !== account
+                || this.cooldowns.get(account) !== state || state.quotaRevision !== revision)
+                return;
+            for (const bucket of update.buckets) {
+                const windows = [bucket.primary, bucket.secondary].filter(window => window !== undefined);
+                // An omitted bucket/window is not evidence of recovery. Exhaustion in
+                // retained windows is still independently enforced by hardBlock().
+                if (windows.length === 0 || windows.some(window => window.utilization >= 1))
+                    continue;
+                if (bucket.limitId === DEFAULT_CODEX_LIMIT_ID) {
+                    state.rateLimitedUntil = 0;
+                    state.globalUntil = state.unavailableUntil;
+                }
+                state.bucketUntil.delete(bucket.limitId);
+            }
+            this.sweepExpiredCooldowns();
+        };
+    }
     getCooldownView(accountId) {
         const account = this.findById(accountId);
         if (!account)
@@ -351,7 +382,7 @@ export class OpenAITokenPool {
     cooldownsFor(account) {
         let state = this.cooldowns.get(account);
         if (!state) {
-            state = { globalUntil: 0, rateLimitedUntil: 0, bucketUntil: new Map() };
+            state = { globalUntil: 0, rateLimitedUntil: 0, unavailableUntil: 0, quotaRevision: 0, bucketUntil: new Map() };
             this.cooldowns.set(account, state);
         }
         return state;
@@ -363,6 +394,8 @@ export class OpenAITokenPool {
             return false;
         const now = this.now();
         let recovered = false;
+        if (state.unavailableUntil > 0 && state.unavailableUntil <= now)
+            state.unavailableUntil = 0;
         if (state.rateLimitedUntil > 0 && state.rateLimitedUntil <= now)
             state.rateLimitedUntil = 0;
         if (state.globalUntil > 0 && state.globalUntil <= now) {

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

@@ -0,0 +1,30 @@
+export async function consumeCodexResetCredit(account, redeemRequestId) {
+    // Contract: openai/codex 1715e55076737158ba61d43158ede504de6d4ce1,
+    // codex-rs/backend-client/src/client/rate_limit_resets.rs and types.rs.
+    // Never retry a spend with a fresh ID: a lost response may have consumed it.
+    try {
+        const response = await fetch("https://chatgpt.com/backend-api/wham/rate-limit-reset-credits/consume", {
+            method: "POST",
+            headers: {
+                authorization: `Bearer ${account.accessToken}`,
+                "content-type": "application/json",
+            },
+            body: JSON.stringify({ redeem_request_id: redeemRequestId }),
+            signal: AbortSignal.timeout(10_000),
+            redirect: "error",
+        });
+        if (response.ok) {
+            const body = await response.json();
+            if (body && typeof body === "object" && "code" in body) {
+                const code = body.code;
+                if (code === "reset" || code === "nothing_to_reset" || code === "no_credit" || code === "already_redeemed") {
+                    return { code };
+                }
+            }
+        }
+    }
+    catch {
+        // Do not relay upstream bodies, credentials, or network error details.
+    }
+    throw new Error("Reset outcome unknown; retry with the same redemption ID");
+}

package/dist/proxy/account-usage-reset.js

@@ -0,0 +1,64 @@
+export function createUsageResetHandler(options) {
+    const inFlight = new WeakSet();
+    // One retained snapshot per account allows an uncertain retry to reconcile
+    // using the ORIGINAL quota evidence, not quota learned after the first spend.
+    const snapshots = new WeakMap();
+    return async (req, res) => {
+        const id = req.params.id;
+        const requestId = req.body?.redeemRequestId;
+        if (typeof requestId !== "string" || !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(requestId)) {
+            res.status(400).json({ error: "redeemRequestId must be a UUID" });
+            return;
+        }
+        const account = options.findAccount(id);
+        if (!account) {
+            res.status(404).json({ error: "ChatGPT account not found" });
+            return;
+        }
+        if (inFlight.has(account)) {
+            res.status(409).json({ error: "Reset already running for this account" });
+            return;
+        }
+        inFlight.add(account);
+        try {
+            if (!await options.prepare(account)) {
+                res.status(503).json({ error: "Account credentials unavailable; reset not submitted" });
+                return;
+            }
+            if (options.findAccount(id) !== account) {
+                res.status(404).json({ error: "ChatGPT account changed; reset not submitted" });
+                return;
+            }
+            const previous = snapshots.get(account);
+            const replay = previous?.id === requestId;
+            const snapshot = replay ? previous : { id: requestId, reconcile: options.captureReset?.(account) };
+            snapshots.set(account, snapshot);
+            const result = await options.consume(account, requestId);
+            if (result.code === "already_redeemed" && !replay) {
+                // This UUID predates our ownership. Repeated historical replays must
+                // never promote its newly captured quota snapshot into trusted evidence.
+                snapshot.reconcile = undefined;
+            }
+            // Refresh even for no_credit/nothing_to_reset: the displayed snapshot may
+            // be stale. Never fabricate windows or decrement credits locally.
+            let usageRefreshed = false;
+            if (options.findAccount(id) === account) {
+                try {
+                    const usage = await options.refresh(account);
+                    usageRefreshed = usage.ok;
+                    if (usage.ok && (result.code === "reset" || (result.code === "already_redeemed" && replay))) {
+                        snapshot.reconcile?.(usage.update);
+                    }
+                }
+                catch { /* retain confirmed redemption */ }
+            }
+            res.json({ reset: { ...result, usageRefreshed } });
+        }
+        catch {
+            res.status(502).json({ error: "Reset outcome unknown; retry with the same redemption ID" });
+        }
+        finally {
+            inFlight.delete(account);
+        }
+    };
+}

package/dist/proxy/server.js

@@ -1,3 +1,5 @@
+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";
@@ -595,6 +597,13 @@ export async function startServer(opts = {}) {
     // 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();

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";
@@ -531,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}`;
@@ -608,14 +612,14 @@ export function Dashboard({ port, baseUrl, authToken, onIntent }) {
     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, onRefreshAll: refreshLocalViews }));
+    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, onRefreshAll, }) {
+function LiveDashboard({ data, port, baseUrl, lastUpdate, api, modelsApi, onIntent, onRefreshAll, resetSession, }) {
     const [cliRouting, setCliRouting] = useState(() => ({
         claude: readClaudeRouting(),
         codex: readCodexRouting(),
@@ -641,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,
@@ -959,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) ───────────────────────────────────────
@@ -990,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") {
@@ -1019,6 +1064,27 @@ 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;
@@ -1164,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
@@ -1172,7 +1238,7 @@ 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  [R] reload  [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  [R] reload all  [Esc] logs  [z] compact  [q]"
                                 : " [Tab]  [m] models  [R] reload  [z] compact  [q] quit" }) })] }) }));

package/dist/ui/accountsApi.js

@@ -57,6 +57,22 @@ export function createAccountsApi(baseUrl, authToken) {
     return {
         list,
         refreshAll,
+        async resetUsage(id, redeemRequestId) {
+            const response = await fetch(`${base}/${encodeURIComponent(id)}/reset-usage`, {
+                method: "POST",
+                headers: { ...authHeaders, "content-type": "application/json" },
+                body: JSON.stringify({ redeemRequestId }),
+                signal: AbortSignal.timeout(REFRESH_ALL_TIMEOUT_MS),
+            });
+            if (!response.ok)
+                throw new Error(`HTTP ${response.status}`);
+            const body = await response.json();
+            const reset = isRecord(body) ? body.reset : undefined;
+            if (!isRecord(reset) || typeof reset.code !== "string" || !["reset", "nothing_to_reset", "no_credit", "already_redeemed"].includes(reset.code)
+                || typeof reset.usageRefreshed !== "boolean")
+                throw new Error("Invalid reset response");
+            return { code: reset.code, usageRefreshed: reset.usageRefreshed };
+        },
         patch(id, patch) { return send("PATCH", `/${encodeURIComponent(id)}`, patch); },
         setProviderEnabled(provider, enabled) { return send("PATCH", `/providers/${encodeURIComponent(provider)}`, { enabled }); },
         remove(id) { return send("DELETE", `/${encodeURIComponent(id)}`); },

package/package.json

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