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

package/CHANGELOG.md

@@ -8,6 +8,38 @@ This project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+### Added
+
+- `cc-router accounts rename <id> <new-id>`. An account's id is the key its
+  routing state hangs off — in-flight counters and sticky session bindings are
+  both id-keyed — so on a running proxy the rename runs as a transaction
+  (`PATCH /cc-router/accounts/:id` with `{"id": ...}`): pool, session router,
+  and accounts.json move together, and are rolled back together if persistence
+  fails. Sticky sessions keep their prompt-cache affinity through the rename.
+  With no proxy running the record is renamed on disk. A proxy from before
+  this feature answers the PATCH with 200 having silently ignored the field —
+  that is detected and reported as an error rather than falling back to a disk
+  write its refresh loop would overwrite. The id namespace is shared across
+  both providers, so a rename onto any existing account name is refused (409).
+
+- The health endpoint reports the daemon's version, and the dashboard shows a
+  version-mismatch banner when the daemon runs a different build than the CLI
+  rendering it. A service manager can keep an old build alive long after an
+  upgrade — launchd pins the versioned pnpm store path in its plist, so the
+  daemon silently stays on the old version across upgrades and even reboots —
+  and every log row and account view on the dashboard comes from that build.
+  Until now nothing surfaced this: a fix could ship, the package could update,
+  and the dashboard would still render the old daemon's output as if the new
+  version were broken. A daemon that reports no version at all predates the
+  field, which is itself proof it is outdated, and banners the same way.
+- The activity list scrolls to follow its selection. The dashboard renders the
+  newest 20 of up to 50 entries, but the arrow keys would walk the selection
+  through all 50 — past row 20 the highlight left the screen while the detail
+  panel kept updating for rows that were not visible. The window now shifts by
+  one row when the selection steps past its bottom or top edge, stays put while
+  the selection moves inside it, and re-clamps when new entries push the
+  selected row (which is timestamp-anchored) out of the stored window.
+
 ### Fixed
 
 - OpenAI activity rows carry the same columns as Claude ones. The OpenAI ingress

package/dist/cli/cmd-accounts.js

@@ -1,10 +1,11 @@
 import chalk from "chalk";
-import { loadAccounts, loadOpenAIAccounts, accountsFileExists, upsertAccountRecord, removeAccountRecordById, readConfig, serialize } from "../config/manager.js";
+import { loadAccounts, loadOpenAIAccounts, accountsFileExists, upsertAccountRecord, removeAccountRecordById, renameAccountRecordById, readConfig, serialize } from "../config/manager.js";
 import { saveAccounts } from "../proxy/token-refresher.js";
 import { formatExpiry, redactToken } from "../utils/token-extractor.js";
 import { PROXY_PORT } from "../config/paths.js";
 import { createOpenAIAccountRecord } from "../providers/openai/account-record.js";
 import { loginOpenAIWithDeviceCode } from "../providers/openai/device-oauth.js";
+import { isValidAccountId } from "../proxy/account-rename.js";
 export function registerAccounts(program) {
     const accounts = program
         .command("accounts")
@@ -233,6 +234,47 @@ export function registerAccounts(program) {
             console.log(chalk.yellow("  No accounts left. Run: cc-router setup"));
         }
     });
+    accounts
+        .command("rename <id> <new-id>")
+        .description("Rename an account — its routing state and sticky sessions follow the new name")
+        .action(async (id, newId) => {
+        if (!accountsFileExists()) {
+            console.log(chalk.yellow("No accounts configured."));
+            return;
+        }
+        if (!isValidAccountId(newId)) {
+            console.log(chalk.red(`✗ "${newId}" is not a valid account name.`));
+            console.log(chalk.gray("  1-64 characters: alphanumeric start, then letters, digits, dots, underscores, or dashes."));
+            process.exit(1);
+        }
+        const { ids: existingIds } = mergeAccountInventory(loadAccounts().map(a => a.id), loadOpenAIAccounts().map(a => a.id), await fetchLiveStats());
+        if (!existingIds.includes(id)) {
+            console.log(chalk.red(`✗ Account "${id}" not found.`));
+            console.log(chalk.gray(`  Available: ${existingIds.join(", ")}`));
+            process.exit(1);
+        }
+        if (id === newId) {
+            console.log(chalk.gray(`Account is already named "${newId}".`));
+            return;
+        }
+        if (existingIds.includes(newId)) {
+            console.log(chalk.red(`✗ An account named "${newId}" already exists.`));
+            process.exit(1);
+        }
+        let result;
+        try {
+            result = await renameAccountRuntimeAware(id, newId);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            console.log(chalk.red(`✗ Could not rename "${id}": ${message}`));
+            process.exit(1);
+        }
+        console.log(chalk.green(`✓ Renamed "${id}" → "${newId}".`));
+        console.log(result.mode === "live"
+            ? chalk.gray("  Applied to the running proxy — in-flight requests and sticky sessions follow the new name.")
+            : chalk.gray("  Saved to accounts.json — loads on next start: cc-router start"));
+    });
 }
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 /** Tell the user whether the new account is already live or needs a restart. */
@@ -326,6 +368,66 @@ export async function tryRemoveAccountFromRunningProxy(id, options = {}) {
     }
     return true;
 }
+/**
+ * Rename an account on a running proxy. Returns false only when no proxy can
+ * be reached (the caller then renames on disk); HTTP errors are authoritative
+ * and thrown. A 200 whose returned account still carries the old id means the
+ * proxy predates rename support — its patch validation drops unknown fields
+ * and reports success having done nothing — and MUST be an error, not a
+ * fallthrough to disk: that proxy's refresh loop persists its own snapshot
+ * over accounts.json and would silently undo a disk-side rename.
+ */
+export async function tryRenameAccountOnRunningProxy(id, newId, options = {}) {
+    const fetchImpl = options.fetch ?? globalThis.fetch;
+    const baseUrl = (options.baseUrl ?? `http://localhost:${PROXY_PORT}`).replace(/\/+$/, "");
+    const authToken = options.authToken ?? readConfig().proxySecret;
+    let response;
+    try {
+        response = await fetchImpl(`${baseUrl}/cc-router/accounts/${encodeURIComponent(id)}`, {
+            method: "PATCH",
+            headers: {
+                "content-type": "application/json",
+                ...(authToken ? { authorization: `Bearer ${authToken}` } : {}),
+            },
+            body: JSON.stringify({ id: newId }),
+            signal: AbortSignal.timeout(3_000),
+        });
+    }
+    catch {
+        return false;
+    }
+    if (!response.ok) {
+        let detail = "";
+        try {
+            const payload = await response.json();
+            if (typeof payload.error === "string")
+                detail = `: ${payload.error}`;
+        }
+        catch { /* best effort */ }
+        throw new Error(`HTTP ${response.status}${detail}`);
+    }
+    let renamedId;
+    try {
+        const payload = await response.json();
+        renamedId = payload.account?.id;
+    }
+    catch { /* fall through to the mismatch error below */ }
+    if (renamedId !== newId) {
+        throw new Error("the running proxy does not support rename (older version) — update and restart it first: cc-router stop --keep-config && cc-router start");
+    }
+    return true;
+}
+export async function renameAccountRuntimeAware(id, newId, dependencies = {
+    tryRenameLive: tryRenameAccountOnRunningProxy,
+    renameStored: renameAccountRecordById,
+}) {
+    if (await dependencies.tryRenameLive(id, newId))
+        return { mode: "live" };
+    const renamed = dependencies.renameStored(id, newId);
+    if (!renamed)
+        throw new Error(`Account "${id}" disappeared before it could be renamed`);
+    return { mode: "stored", renamed };
+}
 export async function removeAccountRuntimeAware(id, dependencies = {
     tryRemoveLive: tryRemoveAccountFromRunningProxy,
     removeStored: removeAccountRecordById,

package/dist/config/manager.js

@@ -90,6 +90,25 @@ export function removeAccountRecordById(id) {
     writeAccountsAtomicToPath(ACCOUNTS_PATH, existing.filter(a => a.id !== id));
     return removed;
 }
+/**
+ * Rename a stored account record in place, keeping every other field. The
+ * uniqueness check spans ALL providers — both live in one accounts.json and
+ * one URL namespace, so two records sharing an id would be unaddressable.
+ * Returns the renamed record, or null if no record has `oldId`.
+ */
+export function renameAccountRecordById(oldId, newId) {
+    ensureConfigDir();
+    const existing = readAccountsRaw();
+    const target = existing.find(a => a.id === oldId) ?? null;
+    if (!target)
+        return null;
+    if (newId !== oldId && existing.some(a => a.id === newId)) {
+        throw new Error(`An account named "${newId}" already exists`);
+    }
+    target.id = newId;
+    writeAccountsAtomicToPath(ACCOUNTS_PATH, existing);
+    return target;
+}
 function normalizeAccountProvider(record) {
     return record.provider === "openai_subscription"
         ? "openai_subscription"

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

@@ -175,6 +175,28 @@ export class OpenAITokenPool {
     findById(id) {
         return this.accounts.find(account => account.id === id) ?? null;
     }
+    /**
+     * Change an account's id in place. The in-flight counter is keyed by id and
+     * must move with it — an open lease's release() re-reads `account.id`, so
+     * after a rename it decrements the NEW key, which would otherwise never
+     * have been incremented. Cooldowns are keyed by the account object and
+     * follow the rename untouched. Returns the renamed account, or null if the
+     * id was not found. Callers are responsible for id-uniqueness and for
+     * session-binding migration. Mirrors `TokenPool.renameAccount`.
+     */
+    renameAccount(oldId, newId) {
+        const account = this.findById(oldId);
+        if (!account)
+            return null;
+        if (newId !== oldId) {
+            const load = this.inFlight.get(oldId);
+            this.inFlight.delete(oldId);
+            if (load !== undefined)
+                this.inFlight.set(newId, load);
+            account.id = newId;
+        }
+        return account;
+    }
     /**
      * Drop every piece of per-account routing state after the account has been
      * removed from the shared `accounts` array. The array splice itself is owned

package/dist/proxy/account-patch.js

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

package/dist/proxy/account-rename.js

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

package/dist/proxy/server.js

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

package/dist/proxy/session-router.js

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

package/dist/proxy/token-pool.js

@@ -599,6 +599,28 @@ export class TokenPool {
         }
         return a;
     }
+    /**
+     * Change an account's id in place. The in-flight counter is keyed by id and
+     * must move with it: an open lease's release() re-reads `account.id`, so
+     * after a rename it decrements the NEW key — which would never have been
+     * incremented, leaving the old key stuck at its count forever. Cooldowns
+     * are keyed by the Account object and follow the rename untouched.
+     * Returns the renamed account, or null if the id was not found. Callers
+     * are responsible for id-uniqueness and for session-binding migration.
+     */
+    renameAccount(oldId, newId) {
+        const account = this.findById(oldId);
+        if (!account)
+            return null;
+        if (newId !== oldId) {
+            const load = this.inFlight.get(oldId);
+            this.inFlight.delete(oldId);
+            if (load !== undefined)
+                this.inFlight.set(newId, load);
+            account.id = newId;
+        }
+        return account;
+    }
     /**
      * Append a new account built from a persisted AccountRecord.
      * Rejects duplicates by id — callers should pre-check with findById().

package/dist/ui/Dashboard.js

@@ -3,9 +3,14 @@ import React, { useState, useEffect, useCallback, useRef } from "react";
 import { Box, Text, useInput, useApp } from "ink";
 import { createAccountsApi } from "./accountsApi.js";
 import { createModelsApi } from "./modelsApi.js";
+import { getCurrentVersion } from "../utils/self-update.js";
 const POLL_INTERVAL_MS = 2_000;
 const LOG_VISIBLE = 20;
 const MODEL_VISIBLE_ROWS = 16;
+const DASHBOARD_VERSION = getCurrentVersion();
+// Distinguishes "this machine's daemon" (restartable from this shell) from a
+// remote router the dashboard is merely pointed at.
+const LOCAL_TARGET_RE = /^https?:\/\/(localhost|127\.0\.0\.1|\[::1\])(:\d+)?$/i;
 const EMPTY_RL = {
     status: "unknown", fiveHourUtil: 0, fiveHourReset: 0,
     sevenDayUtil: 0, sevenDayReset: 0, claim: "", plan: "",
@@ -208,6 +213,24 @@ export function isCodexLimited(codex) {
         return false;
     return (defaultBucket.primary?.utilization ?? 0) >= 1 || (defaultBucket.secondary?.utilization ?? 0) >= 1;
 }
+/**
+ * First visible row of a scrolling list window that follows its selection.
+ *
+ * The window stays where it is while the selection moves inside it, and
+ * shifts just far enough to contain the selection when it crosses an edge —
+ * one row per one-row step, but any distance when the selection jumps (it is
+ * timestamp-anchored, so a burst of new entries can move it many rows at
+ * once). A stale `scrollTop` from a longer list clamps back into range.
+ */
+export function followScrollWindow(scrollTop, selectedIndex, total, visible) {
+    const maxTop = Math.max(0, total - visible);
+    let top = Math.min(Math.max(0, scrollTop), maxTop);
+    if (selectedIndex < top)
+        top = selectedIndex;
+    else if (selectedIndex > top + visible - 1)
+        top = selectedIndex - visible + 1;
+    return Math.min(Math.max(0, top), maxTop);
+}
 export function Dashboard({ port, baseUrl, authToken, onIntent }) {
     const { exit } = useApp();
     const [data, setData] = useState(null);
@@ -285,6 +308,12 @@ function LiveDashboard({ data, port, baseUrl, lastUpdate, api, modelsApi, onInte
     const selectedLogIndex = selectedTs !== null
         ? Math.max(0, logs.findIndex(l => l.ts === selectedTs))
         : 0;
+    // First visible activity row. The stored position only moves on navigation;
+    // the derived value re-clamps every render because the selection is
+    // timestamp-anchored — new entries arriving between keypresses can push the
+    // selected row out of the stored window, and it must stay visible anyway.
+    const [logScrollTop, setLogScrollTop] = useState(0);
+    const logWindowTop = followScrollWindow(logScrollTop, selectedLogIndex, logs.length, LOG_VISIBLE);
     // Selected account by id
     const [selectedAccountId, setSelectedAccountId] = useState(null);
     const selectedAccountIndex = selectedAccountId !== null
@@ -494,10 +523,12 @@ function LiveDashboard({ data, port, baseUrl, lastUpdate, api, modelsApi, onInte
             if (key.upArrow) {
                 const next = Math.max(0, selectedLogIndex - 1);
                 setSelectedTs(logs[next]?.ts ?? null);
+                setLogScrollTop(followScrollWindow(logWindowTop, next, logs.length, LOG_VISIBLE));
             }
             if (key.downArrow) {
                 const next = Math.min(logs.length - 1, selectedLogIndex + 1);
                 setSelectedTs(logs[next]?.ts ?? null);
+                setLogScrollTop(followScrollWindow(logWindowTop, next, logs.length, LOG_VISIBLE));
             }
         }
         if (focus === "accounts") {
@@ -580,10 +611,15 @@ function LiveDashboard({ data, port, baseUrl, lastUpdate, api, modelsApi, onInte
         }
     });
     const selectedLog = logs[selectedLogIndex] ?? null;
-    const visibleLogs = logs.slice(0, LOG_VISIBLE);
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, color: "cyan", children: " CC-Router " }), _jsx(Text, { color: "gray", children: "\u00B7 " }), _jsx(Text, { color: "green", children: data.mode }), _jsxs(Text, { color: "gray", children: [" \u2192 ", data.target, "  \u00B7 "] }), _jsxs(Text, { children: ["up ", formatUptime(data.uptime)] }), _jsxs(Text, { color: "gray", children: ["  \u00B7  updated ", updatedAgo, "s ago  \u00B7  [q] quit"] })] }), _jsx(Box, { marginTop: 1 }), data.operational && (_jsxs(_Fragment, { children: [_jsx(OperationsPanel, { operational: data.operational, baseUrl: baseUrl, focus: focus }), _jsx(Box, { marginTop: 1 })] })), (focus === "models" || modelsStatus) && (_jsxs(_Fragment, { children: [_jsx(ModelsPanel, { status: modelsStatus, selectedIndex: selectedModelIndex, focused: focus === "models" }), _jsx(Box, { marginTop: 1 })] })), _jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsxs(Text, { bold: true, children: [" ACCOUNTS  ", _jsxs(Text, { color: healthyCount === data.accounts.length ? "green" : "yellow", children: [healthyCount, "/", data.accounts.length, " healthy"] })] }), _jsx(Text, { color: "gray", children: "   " }), _jsx(Text, { color: focus === "accounts" ? "white" : "gray", children: "[Tab] focus  [e] toggle  [a] Claude all  [o] OpenAI all  [w] 7d cap  [s] 5h cap  [n] add  [d] delete" })] }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: data.accounts.map((a, i) => (_jsx(AccountRow, { account: a, selected: focus === "accounts" && i === selectedAccountIndex }, a.id))) })] }), mode === "editWeekly" && selectedAccount && (_jsxs(Box, { marginTop: 1, paddingLeft: 2, children: [_jsx(Text, { color: "cyan", children: "Set 7d cap for " }), _jsx(Text, { color: "white", bold: true, children: selectedAccount.id }), _jsx(Text, { color: "cyan", children: " (0\u2013100%): " }), _jsx(Text, { color: "white", bold: true, children: editBuffer }), _jsx(Text, { color: "gray", children: "\u2588  [Enter] save  [Esc] cancel" })] })), mode === "editSession" && selectedAccount && (_jsxs(Box, { marginTop: 1, paddingLeft: 2, children: [_jsx(Text, { color: "cyan", children: "Set 5h cap for " }), _jsx(Text, { color: "white", bold: true, children: selectedAccount.id }), _jsx(Text, { color: "cyan", children: " (0\u2013100%): " }), _jsx(Text, { color: "white", bold: true, children: editBuffer }), _jsx(Text, { color: "gray", children: "\u2588  [Enter] save  [Esc] cancel" })] })), mode === "confirmDelete" && selectedAccount && (_jsx(Box, { marginTop: 1, paddingLeft: 2, children: _jsxs(Text, { color: "red", bold: true, children: ["Delete \"", selectedAccount.id, "\"?  [y] yes  [n/Esc] cancel"] }) })), banner && (_jsx(Box, { marginTop: 1, paddingLeft: 2, children: _jsxs(Text, { color: banner.color, children: [" ", banner.text] }) })), _jsx(Box, { marginTop: 1 }), _jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, children: " TOTALS  " }), _jsx(Text, { children: "requests " }), _jsx(Text, { color: "cyan", children: data.totalRequests }), _jsx(Text, { color: "gray", children: "  \u00B7  " }), _jsx(Text, { children: "errors " }), _jsx(Text, { color: data.totalErrors > 0 ? "red" : "green", children: data.totalErrors }), _jsx(Text, { color: "gray", children: "  \u00B7  " }), _jsx(Text, { children: "refreshes " }), _jsx(Text, { color: "yellow", children: data.totalRefreshes }), _jsx(CacheHealthBadge, { read: data.totalCacheReadTokens, created: data.totalCacheCreationTokens, input: data.totalInputTokens })] }), _jsx(TokenSummary, { cacheRead: data.totalCacheReadTokens, cacheCreated: data.totalCacheCreationTokens, uncached: data.totalInputTokens, output: data.totalOutputTokens ?? 0 })] }), _jsx(Box, { marginTop: 1 }), _jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: " RECENT ACTIVITY" }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: visibleLogs.length === 0
+    const visibleLogs = logs.slice(logWindowTop, logWindowTop + LOG_VISIBLE);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, color: "cyan", children: " CC-Router " }), _jsx(Text, { color: "gray", children: "\u00B7 " }), _jsx(Text, { color: "green", children: data.mode }), _jsxs(Text, { color: "gray", children: [" \u2192 ", data.target, "  \u00B7 "] }), _jsxs(Text, { children: ["up ", formatUptime(data.uptime)] }), _jsxs(Text, { color: "gray", children: ["  \u00B7  updated ", updatedAgo, "s ago  \u00B7  [q] quit"] })] }), data.version !== DASHBOARD_VERSION && (_jsxs(Box, { children: [_jsx(Text, { bold: true, color: "yellow", children: " \u26A0 VERSION MISMATCH  " }), _jsxs(Text, { color: "yellow", children: [data.version !== undefined
+                                ? `daemon v${data.version}`
+                                : "daemon version unreported (older build)", ` · dashboard v${DASHBOARD_VERSION}`] }), LOCAL_TARGET_RE.test(baseUrl) ? (_jsxs(_Fragment, { children: [_jsx(Text, { color: "gray", children: "  \u2014  restart: " }), _jsx(Text, { color: "cyan", children: "cc-router stop --keep-config && cc-router start" })] })) : (
+                    // A remote router can only be restarted where it runs; printing a
+                    // local restart command here would never clear the banner.
+                    _jsxs(Text, { color: "gray", children: ["  \u2014  update and restart the daemon on ", baseUrl] }))] })), _jsx(Box, { marginTop: 1 }), data.operational && (_jsxs(_Fragment, { children: [_jsx(OperationsPanel, { operational: data.operational, baseUrl: baseUrl, focus: focus }), _jsx(Box, { marginTop: 1 })] })), (focus === "models" || modelsStatus) && (_jsxs(_Fragment, { children: [_jsx(ModelsPanel, { status: modelsStatus, selectedIndex: selectedModelIndex, focused: focus === "models" }), _jsx(Box, { marginTop: 1 })] })), _jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsxs(Text, { bold: true, children: [" ACCOUNTS  ", _jsxs(Text, { color: healthyCount === data.accounts.length ? "green" : "yellow", children: [healthyCount, "/", data.accounts.length, " healthy"] })] }), _jsx(Text, { color: "gray", children: "   " }), _jsx(Text, { color: focus === "accounts" ? "white" : "gray", children: "[Tab] focus  [e] toggle  [a] Claude all  [o] OpenAI all  [w] 7d cap  [s] 5h cap  [n] add  [d] delete" })] }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: data.accounts.map((a, i) => (_jsx(AccountRow, { account: a, selected: focus === "accounts" && i === selectedAccountIndex }, a.id))) })] }), mode === "editWeekly" && selectedAccount && (_jsxs(Box, { marginTop: 1, paddingLeft: 2, children: [_jsx(Text, { color: "cyan", children: "Set 7d cap for " }), _jsx(Text, { color: "white", bold: true, children: selectedAccount.id }), _jsx(Text, { color: "cyan", children: " (0\u2013100%): " }), _jsx(Text, { color: "white", bold: true, children: editBuffer }), _jsx(Text, { color: "gray", children: "\u2588  [Enter] save  [Esc] cancel" })] })), mode === "editSession" && selectedAccount && (_jsxs(Box, { marginTop: 1, paddingLeft: 2, children: [_jsx(Text, { color: "cyan", children: "Set 5h cap for " }), _jsx(Text, { color: "white", bold: true, children: selectedAccount.id }), _jsx(Text, { color: "cyan", children: " (0\u2013100%): " }), _jsx(Text, { color: "white", bold: true, children: editBuffer }), _jsx(Text, { color: "gray", children: "\u2588  [Enter] save  [Esc] cancel" })] })), mode === "confirmDelete" && selectedAccount && (_jsx(Box, { marginTop: 1, paddingLeft: 2, children: _jsxs(Text, { color: "red", bold: true, children: ["Delete \"", selectedAccount.id, "\"?  [y] yes  [n/Esc] cancel"] }) })), banner && (_jsx(Box, { marginTop: 1, paddingLeft: 2, children: _jsxs(Text, { color: banner.color, children: [" ", banner.text] }) })), _jsx(Box, { marginTop: 1 }), _jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, children: " TOTALS  " }), _jsx(Text, { children: "requests " }), _jsx(Text, { color: "cyan", children: data.totalRequests }), _jsx(Text, { color: "gray", children: "  \u00B7  " }), _jsx(Text, { children: "errors " }), _jsx(Text, { color: data.totalErrors > 0 ? "red" : "green", children: data.totalErrors }), _jsx(Text, { color: "gray", children: "  \u00B7  " }), _jsx(Text, { children: "refreshes " }), _jsx(Text, { color: "yellow", children: data.totalRefreshes }), _jsx(CacheHealthBadge, { read: data.totalCacheReadTokens, created: data.totalCacheCreationTokens, input: data.totalInputTokens })] }), _jsx(TokenSummary, { cacheRead: data.totalCacheReadTokens, cacheCreated: data.totalCacheCreationTokens, uncached: data.totalInputTokens, output: data.totalOutputTokens ?? 0 })] }), _jsx(Box, { marginTop: 1 }), _jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: " RECENT ACTIVITY" }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: visibleLogs.length === 0
                             ? _jsx(Text, { color: "gray", children: "  No activity yet" })
-                            : visibleLogs.map((log, i) => (_jsx(LogRow, { log: log, selected: focus === "logs" && i === selectedLogIndex }, `${log.ts}-${i}`))) })] }), focus === "logs" && selectedLog && (_jsxs(_Fragment, { children: [_jsx(Box, { marginTop: 1 }), _jsx(DetailPanel, { log: selectedLog })] }))] }));
+                            : visibleLogs.map((log, i) => (_jsx(LogRow, { log: log, selected: focus === "logs" && logWindowTop + i === selectedLogIndex }, `${log.ts}-${i}`))) })] }), focus === "logs" && selectedLog && (_jsxs(_Fragment, { children: [_jsx(Box, { marginTop: 1 }), _jsx(DetailPanel, { log: selectedLog })] }))] }));
 }
 function OperationsPanel({ operational, baseUrl, focus }) {
     const authLabel = operational.auth.required ? "protected" : "open";

package/package.json

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