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

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

@@ -7,6 +7,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
@@ -543,22 +546,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 +593,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 }));
 }
 // ─── 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, }) {
     const [cliRouting, setCliRouting] = useState(() => ({
         claude: readClaudeRouting(),
         codex: readCodexRouting(),
@@ -770,14 +778,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 +880,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"
@@ -970,6 +1019,10 @@ function LiveDashboard({ data, port, baseUrl, lastUpdate, api, modelsApi, onInte
             exit();
             return;
         }
+        if (input === "R") {
+            void doRefreshAll();
+            return;
+        }
         if (key.tab) {
             // Compact view hides the activity list, so skip "logs" in the cycle.
             if (compact) {
@@ -1119,10 +1172,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  [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";

package/dist/ui/accountsApi.js

@@ -6,9 +6,15 @@
  * flow is not here because it runs inquirer.
  */
 const REQUEST_TIMEOUT_MS = 3_000;
+// Worst case is every account timing out: OpenAI token refreshes are
+// sequential with a 15s deadline each, usage fetches run two at a time with
+// 10s each. The server single-flights the pass, so a client that does give
+// up and presses again joins the running one rather than stacking another.
+const REFRESH_ALL_TIMEOUT_MS = 120_000;
 const MAX_PUBLIC_ROWS = 12;
 export function createAccountsApi(baseUrl, authToken) {
-    const base = baseUrl.replace(/\/+$/, "") + "/cc-router/accounts";
+    const root = baseUrl.replace(/\/+$/, "");
+    const base = root + "/cc-router/accounts";
     const authHeaders = authToken ? { authorization: `Bearer ${authToken}` } : {};
     async function send(method, path, body) {
         const res = await fetch(base + path, {
@@ -35,13 +41,37 @@ export function createAccountsApi(baseUrl, authToken) {
         const payload = await res.json();
         return Array.isArray(payload.accounts) ? payload.accounts.flatMap(publicAccountSafeView) : [];
     }
+    async function refreshAll() {
+        // Usage fetches for every account run behind this call, so it gets its
+        // own, longer budget than the account mutations above.
+        const res = await fetch(root + "/cc-router/refresh", {
+            method: "POST",
+            headers: authHeaders,
+            signal: AbortSignal.timeout(REFRESH_ALL_TIMEOUT_MS),
+        });
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status}`);
+        const payload = await res.json();
+        return publicRefreshResult(payload.refresh);
+    }
     return {
         list,
+        refreshAll,
         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)}`); },
     };
 }
+function publicRefreshResult(value) {
+    const record = isRecord(value) ? value : {};
+    return {
+        accounts: publicInteger(record.accounts),
+        usageRefreshed: publicInteger(record.usageRefreshed),
+        usageFailed: publicInteger(record.usageFailed),
+        tokenRefreshFailed: publicInteger(record.tokenRefreshFailed),
+        durationMs: publicInteger(record.durationMs),
+    };
+}
 function isRecord(value) {
     return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }

package/package.json

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