ai-cc-router 0.4.3 → 0.5.0

package/dist/cli/cmd-accounts.js

@@ -1,5 +1,5 @@
 import chalk from "chalk";
-import { loadAccounts, accountsFileExists, writeAccountsAtomic } from "../config/manager.js";
+import { loadAccounts, accountsFileExists, writeAccountsAtomic, 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";
@@ -107,13 +107,7 @@ export function registerAccounts(program) {
             console.log(chalk.gray("Cancelled."));
             return;
         }
-        writeAccountsAtomic(filtered.map(a => ({
-            id: a.id,
-            accessToken: a.tokens.accessToken,
-            refreshToken: a.tokens.refreshToken,
-            expiresAt: a.tokens.expiresAt,
-            scopes: a.tokens.scopes,
-        })));
+        writeAccountsAtomic(serialize(filtered));
         console.log(chalk.green(`✓ Removed "${id}". ${filtered.length} account(s) remaining.`));
         if (filtered.length === 0) {
             console.log(chalk.yellow("  No accounts left. Run: cc-router setup"));

package/dist/cli/cmd-setup.js

@@ -7,7 +7,7 @@ import { writeClaudeSettings, readClaudeProxySettings } from "../utils/claude-co
 import { saveAccounts } from "../proxy/token-refresher.js";
 import { loadAccounts, accountsFileExists, readConfig, writeConfig, generateProxySecret } from "../config/manager.js";
 import { PROXY_PORT } from "../config/paths.js";
-import { DEFAULT_RATE_LIMITS } from "../proxy/types.js";
+import { DEFAULT_RATE_LIMITS, ACCOUNT_USER_DEFAULTS } from "../proxy/types.js";
 import { existsSync } from "fs";
 import { checkMitmproxyInstalled, isCaCertInstalled, generateCaCert, installCaCert, writeAddonScript, getNetworkExtensionStatus, openNetworkExtensionSettings, } from "../interceptor/mitmproxy-manager.js";
 import { printDesktopSupportExplainer, printNetworkExtensionInstructions } from "./cmd-client.js";
@@ -104,6 +104,7 @@ export async function setupSingleAccount(index) {
         lastRefresh: 0,
         consecutiveErrors: 0,
         rateLimits: { ...DEFAULT_RATE_LIMITS },
+        ...ACCOUNT_USER_DEFAULTS,
     };
 }
 // ─── Full wizard ──────────────────────────────────────────────────────────────

package/dist/cli/cmd-status.js

@@ -1,22 +1,30 @@
 import chalk from "chalk";
 import { PROXY_PORT } from "../config/paths.js";
 import { readConfig } from "../config/manager.js";
-/**
- * Resolves where the health endpoint lives.
- *
- * In client mode → remote CC-Router URL (from config)
- * Otherwise      → http://localhost:<port>
- */
-function resolveTarget() {
+export function resolveStatusTarget(port) {
     const cfg = readConfig();
     if (cfg.client) {
         const base = cfg.client.remoteUrl.replace(/\/+$/, "");
         const headers = {};
         if (cfg.client.remoteSecret)
             headers["authorization"] = `Bearer ${cfg.client.remoteSecret}`;
-        return { healthUrl: `${base}/cc-router/health`, headers, baseUrl: base, authToken: cfg.client.remoteSecret };
+        return {
+            baseUrl: base,
+            healthUrl: `${base}/cc-router/health`,
+            headers,
+            authToken: cfg.client.remoteSecret,
+        };
     }
-    return { healthUrl: `http://localhost:${PROXY_PORT}/cc-router/health`, headers: {} };
+    const base = `http://localhost:${port}`;
+    const headers = {};
+    if (cfg.proxySecret)
+        headers["authorization"] = `Bearer ${cfg.proxySecret}`;
+    return {
+        baseUrl: base,
+        healthUrl: `${base}/cc-router/health`,
+        headers,
+        authToken: cfg.proxySecret,
+    };
 }
 export function registerStatus(program) {
     program
@@ -30,11 +38,11 @@ export function registerStatus(program) {
             await jsonOutput(port);
             return;
         }
-        await launchDashboard(port);
+        await dashboardLoop(port);
     });
 }
 async function jsonOutput(port) {
-    const { healthUrl, headers } = resolveTarget();
+    const { healthUrl, headers } = resolveStatusTarget(port);
     try {
         const res = await fetch(healthUrl, {
             headers,
@@ -58,16 +66,91 @@ async function jsonOutput(port) {
         process.exit(1);
     }
 }
-async function launchDashboard(port) {
-    const { baseUrl, authToken } = resolveTarget();
+/**
+ * Launches the Ink dashboard and handles "re-launch" intents.
+ *
+ * The dashboard cannot run inquirer prompts while Ink owns stdin, so when
+ * the user presses `n` to add an account, Ink unmounts and this loop runs
+ * the OAuth flow synchronously. Once tokens are obtained and POSTed to the
+ * server, the dashboard is re-rendered and polling resumes.
+ */
+async function dashboardLoop(port) {
     // Dynamic imports keep these heavy deps out of the cold-start path
     const [{ render }, { createElement }, { Dashboard }] = await Promise.all([
         import("ink"),
         import("react"),
         import("../ui/Dashboard.js"),
     ]);
-    render(createElement(Dashboard, { port, baseUrl, authToken }), {
-        // Let Ink handle Ctrl+C — it calls exit() which cleanly unmounts
-        exitOnCtrlC: true,
-    });
+    while (true) {
+        const target = resolveStatusTarget(port);
+        const intent = await new Promise((resolve) => {
+            const onIntent = (i) => resolve(i);
+            const instance = render(createElement(Dashboard, {
+                port,
+                baseUrl: target.baseUrl,
+                authToken: target.authToken,
+                onIntent,
+            }), 
+            // Let Ink handle Ctrl+C — it calls exit() which cleanly unmounts
+            { exitOnCtrlC: true });
+            // If Ink exits on its own (Ctrl+C or `q`) without firing onIntent, treat as quit.
+            instance.waitUntilExit().then(() => resolve("quit"));
+        });
+        if (intent === "quit")
+            return;
+        // Intent: addAccount — unmount and run the OAuth flow, then POST the
+        // resulting tokens to the server we're connected to (local or remote).
+        console.log();
+        console.log(chalk.cyan("→ Adding a new account..."));
+        console.log();
+        const added = await runAddAccountFlow(target);
+        if (added) {
+            console.log(chalk.green(`\n✓ Account "${added}" added. Returning to dashboard...\n`));
+        }
+        else {
+            console.log(chalk.yellow("\n  No account added. Returning to dashboard...\n"));
+        }
+        // Fall through → loop re-renders the dashboard
+    }
+}
+/**
+ * Runs the existing setupSingleAccount() OAuth flow, then POSTs the resulting
+ * tokens to /cc-router/accounts on the active target. Returns the new id on
+ * success, or null if the user aborted / an error occurred.
+ */
+async function runAddAccountFlow(target) {
+    try {
+        const { setupSingleAccount } = await import("./cmd-setup.js");
+        // The index shown in the flow is just for display, pick something neutral.
+        const account = await setupSingleAccount(1);
+        if (!account)
+            return null;
+        const res = await fetch(`${target.baseUrl}/cc-router/accounts`, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                ...target.headers,
+            },
+            body: JSON.stringify({
+                id: account.id,
+                accessToken: account.tokens.accessToken,
+                refreshToken: account.tokens.refreshToken,
+                expiresAt: account.tokens.expiresAt,
+                scopes: account.tokens.scopes,
+            }),
+            signal: AbortSignal.timeout(5_000),
+        });
+        if (!res.ok) {
+            const text = await res.text().catch(() => "");
+            console.error(chalk.red(`\n✗ Server rejected account: HTTP ${res.status}`));
+            if (text)
+                console.error(chalk.gray(`  ${text}`));
+            return null;
+        }
+        return account.id;
+    }
+    catch (err) {
+        console.error(chalk.red(`\n✗ Failed to add account: ${err.message}`));
+        return null;
+    }
 }

package/dist/config/manager.js

@@ -1,7 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync, copyFileSync } from "fs";
 import { randomBytes } from "crypto";
 import { CONFIG_DIR, ACCOUNTS_PATH, CONFIG_PATH } from "./paths.js";
-import { DEFAULT_RATE_LIMITS } from "../proxy/types.js";
+import { DEFAULT_RATE_LIMITS, ACCOUNT_USER_DEFAULTS, clampPercent } from "../proxy/types.js";
 export function ensureConfigDir() {
     if (!existsSync(CONFIG_DIR)) {
         mkdirSync(CONFIG_DIR, { recursive: true });
@@ -83,5 +83,25 @@ function deserialize(records) {
         lastRefresh: 0,
         consecutiveErrors: 0,
         rateLimits: { ...DEFAULT_RATE_LIMITS },
+        enabled: a.enabled !== false, // default true
+        sessionLimitPercent: a.sessionLimitPercent !== undefined
+            ? clampPercent(a.sessionLimitPercent)
+            : ACCOUNT_USER_DEFAULTS.sessionLimitPercent,
+        weeklyLimitPercent: a.weeklyLimitPercent !== undefined
+            ? clampPercent(a.weeklyLimitPercent)
+            : ACCOUNT_USER_DEFAULTS.weeklyLimitPercent,
+    }));
+}
+/** Serialize runtime Account[] back to the flat on-disk AccountRecord[] shape. */
+export function serialize(accounts) {
+    return accounts.map(a => ({
+        id: a.id,
+        accessToken: a.tokens.accessToken,
+        refreshToken: a.tokens.refreshToken,
+        expiresAt: a.tokens.expiresAt,
+        scopes: a.tokens.scopes,
+        enabled: a.enabled,
+        sessionLimitPercent: a.sessionLimitPercent,
+        weeklyLimitPercent: a.weeklyLimitPercent,
     }));
 }

package/dist/proxy/server.js

@@ -2,9 +2,9 @@ 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 { TokenPool, EmptyPoolError } from "./token-pool.js";
 import { needsRefresh, refreshAccountToken, saveAccounts, startRefreshLoop } from "./token-refresher.js";
-import { loadAccounts, accountsFileExists, readAccountsFromPath, readConfig } from "../config/manager.js";
+import { loadAccounts, accountsFileExists, readAccountsFromPath, readConfig, serialize } from "../config/manager.js";
 import { checkForUpdate, performUpdate, restartSelf } from "../utils/self-update.js";
 import { trackEvent, startHeartbeat } from "../utils/telemetry.js";
 import { loadTelemetryState } from "../config/telemetry.js";
@@ -76,6 +76,13 @@ export async function startServer(opts = {}) {
         process.exit(1);
     }
     const pool = new TokenPool(accounts);
+    // Log when the pool falls back to a capped account — makes the cap bypass
+    // visible in the dashboard's "RECENT ACTIVITY" instead of being silent.
+    pool.onCapBypass = (a) => {
+        const msg = `all accounts capped — routing to ${a.id} (5h: ${Math.round(a.rateLimits.fiveHourUtil * 100)}%, 7d: ${Math.round(a.rateLimits.sevenDayUtil * 100)}%)`;
+        logError(a.id, 0, msg);
+        stats.addLog({ ts: Date.now(), accountId: a.id, model: "-", type: "error", details: msg });
+    };
     startRefreshLoop(accounts);
     const app = express();
     // ─── Proxy auth middleware ─────────────────────────────────────────────────
@@ -124,6 +131,173 @@ export async function startServer(opts = {}) {
             recentLogs: stats.getRecentLogs(50),
         });
     });
+    // ─── 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" }));
+    // Shape returned to clients — NEVER includes access/refresh tokens.
+    const publicAccountView = (a) => ({
+        id: a.id,
+        enabled: a.enabled,
+        sessionLimitPercent: a.sessionLimitPercent,
+        weeklyLimitPercent: a.weeklyLimitPercent,
+        healthy: a.healthy,
+        busy: a.busy,
+        requestCount: a.requestCount,
+        errorCount: a.errorCount,
+        expiresInMs: a.tokens.expiresAt - Date.now(),
+        lastUsedMs: a.lastUsed,
+        lastRefreshMs: a.lastRefresh,
+        rateLimits: a.rateLimits,
+    });
+    accountsRouter.get("/", (_req, res) => {
+        res.json({ accounts: pool.getAll().map(publicAccountView) });
+    });
+    /**
+     * Persist the pool to disk, returning a structured result instead of
+     * throwing. Callers hold a rollback closure for in-memory state in case
+     * the disk write fails — so a ENOSPC / EACCES doesn't leave the server
+     * silently out of sync with accounts.json.
+     */
+    const tryPersist = (rollback) => {
+        try {
+            saveAccounts(pool.getAll());
+            return { ok: true };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            try {
+                rollback();
+            }
+            catch { /* best effort */ }
+            logError("accounts", 0, `Failed to persist accounts.json: ${message}`);
+            return { ok: false, message };
+        }
+    };
+    accountsRouter.patch("/:id", (req, res) => {
+        const { id } = req.params;
+        const body = (req.body ?? {});
+        const patch = {};
+        if (body.enabled !== undefined) {
+            if (typeof body.enabled !== "boolean") {
+                res.status(400).json({ error: "enabled must be boolean" });
+                return;
+            }
+            patch.enabled = body.enabled;
+        }
+        for (const key of ["sessionLimitPercent", "weeklyLimitPercent"]) {
+            const v = body[key];
+            if (v === undefined)
+                continue;
+            if (typeof v !== "number" || !Number.isFinite(v) || v < 0 || v > 100) {
+                res.status(400).json({ error: `${key} must be a number between 0 and 100` });
+                return;
+            }
+            patch[key] = v;
+        }
+        // Snapshot the previous values so we can roll back on persistence failure
+        const existing = pool.findById(id);
+        if (!existing) {
+            res.status(404).json({ error: `Account "${id}" not found` });
+            return;
+        }
+        const prev = {
+            enabled: existing.enabled,
+            sessionLimitPercent: existing.sessionLimitPercent,
+            weeklyLimitPercent: existing.weeklyLimitPercent,
+        };
+        const updated = pool.updateAccount(id, patch);
+        if (!updated) {
+            res.status(404).json({ error: `Account "${id}" not found` });
+            return;
+        }
+        const result = tryPersist(() => {
+            pool.updateAccount(id, prev);
+        });
+        if (!result.ok) {
+            res.status(500).json({ error: `Failed to persist accounts.json: ${result.message}` });
+            return;
+        }
+        res.json({ account: publicAccountView(updated) });
+    });
+    accountsRouter.post("/", (req, res) => {
+        const body = (req.body ?? {});
+        const required = ["id", "accessToken", "refreshToken", "expiresAt"];
+        for (const k of required) {
+            if (body[k] === undefined || body[k] === null || body[k] === "") {
+                res.status(400).json({ error: `Missing required field: ${k}` });
+                return;
+            }
+        }
+        if (typeof body.id !== "string" || typeof body.accessToken !== "string" ||
+            typeof body.refreshToken !== "string" || typeof body.expiresAt !== "number") {
+            res.status(400).json({ error: "Invalid field types on account record" });
+            return;
+        }
+        if (pool.findById(body.id)) {
+            res.status(409).json({ error: `Account "${body.id}" already exists` });
+            return;
+        }
+        const record = {
+            id: body.id,
+            accessToken: body.accessToken,
+            refreshToken: body.refreshToken,
+            expiresAt: body.expiresAt,
+            scopes: Array.isArray(body.scopes) ? body.scopes : ["user:inference", "user:profile"],
+            enabled: body.enabled,
+            sessionLimitPercent: body.sessionLimitPercent,
+            weeklyLimitPercent: body.weeklyLimitPercent,
+        };
+        let added;
+        try {
+            added = pool.addAccount(record);
+        }
+        catch (err) {
+            res.status(400).json({ error: err.message });
+            return;
+        }
+        const result = tryPersist(() => {
+            pool.removeAccount(record.id);
+        });
+        if (!result.ok) {
+            res.status(500).json({ error: `Failed to persist accounts.json: ${result.message}` });
+            return;
+        }
+        res.status(201).json({ account: publicAccountView(added) });
+    });
+    accountsRouter.delete("/:id", (req, res) => {
+        const { id } = req.params;
+        // Refuse to remove the last account — downstream /v1/* would have no
+        // token to route with and the pool would throw EmptyPoolError on the
+        // next request. Users who want an empty pool should `cc-router stop`.
+        if (pool.getAll().length <= 1) {
+            res.status(409).json({ error: "Cannot remove the last account — at least one must remain" });
+            return;
+        }
+        const existing = pool.findById(id);
+        if (!existing) {
+            res.status(404).json({ error: `Account "${id}" not found` });
+            return;
+        }
+        // Snapshot for rollback. serialize() gives us a persistable AccountRecord.
+        const snapshot = serialize([existing])[0];
+        const removed = pool.removeAccount(id);
+        if (!removed) {
+            res.status(404).json({ error: `Account "${id}" not found` });
+            return;
+        }
+        const result = tryPersist(() => {
+            pool.addAccount(snapshot);
+        });
+        if (!result.ok) {
+            res.status(500).json({ error: `Failed to persist accounts.json: ${result.message}` });
+            return;
+        }
+        res.json({ ok: true, id });
+    });
+    app.use("/cc-router/accounts", accountsRouter);
     // ─── Proxy middleware ──────────────────────────────────────────────────────
     // IMPORTANT: selfHandleResponse must be false (default) for SSE streaming to
     // work transparently. Setting it to true breaks streaming.
@@ -310,8 +484,23 @@ export async function startServer(opts = {}) {
     // ─── /v1/* — select account, refresh if needed, then proxy ───────────────
     // CRITICAL: Do NOT use express.json() here — it consumes the body stream
     // and breaks SSE streaming passthrough.
-    app.use("/v1", async (req, _res, next) => {
-        const account = pool.getNext();
+    app.use("/v1", async (req, res, next) => {
+        let account;
+        try {
+            account = pool.getNext();
+        }
+        catch (err) {
+            if (err instanceof EmptyPoolError) {
+                stats.totalErrors++;
+                logError("proxy", 503, err.message);
+                res.status(503).json({
+                    type: "error",
+                    error: { type: "no_accounts", message: err.message },
+                });
+                return;
+            }
+            throw err;
+        }
         // Synchronous refresh if token expires within the buffer window
         if (needsRefresh(account)) {
             const ok = await refreshAccountToken(account);

package/dist/proxy/token-pool.js

@@ -1,3 +1,10 @@
+import { DEFAULT_RATE_LIMITS, ACCOUNT_USER_DEFAULTS, clampPercent } from "./types.js";
+export class EmptyPoolError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "EmptyPoolError";
+    }
+}
 /** Returns the earliest non-zero reset timestamp (seconds) for an account. */
 function earliestReset(a) {
     const r = a.rateLimits;
@@ -5,6 +12,15 @@ function earliestReset(a) {
         return Math.min(r.fiveHourReset, r.sevenDayReset);
     return r.fiveHourReset || r.sevenDayReset || Infinity;
 }
+/** True when the account's user-defined caps have been reached. */
+function overUserCap(a) {
+    return (a.rateLimits.fiveHourUtil * 100 >= a.sessionLimitPercent ||
+        a.rateLimits.sevenDayUtil * 100 >= a.weeklyLimitPercent);
+}
+/** Filter out accounts the user has taken out of the rotation. */
+function isUsable(a) {
+    return a.enabled && !overUserCap(a);
+}
 export class TokenPool {
     accounts;
     currentIndex = 0;
@@ -12,24 +28,52 @@ export class TokenPool {
         this.accounts = accounts;
     }
     /**
-     * Round-robin selection among healthy, non-busy, non-rate-limited accounts.
-     * Falls back to least-loaded if all are busy/limited.
-     * When all are rate-limited, picks the one with the earliest reset.
-     * Falls back to accounts[0] if all are unhealthy.
+     * Round-robin selection among accounts that are:
+     *   • healthy
+     *   • not busy
+     *   • not rate-limited by Anthropic
+     *   • enabled (user toggle)
+     *   • under the user-configured 5h/7d caps
+     *
+     * Fallback chain when nothing is available:
+     *   1. Any healthy+usable (enabled & under caps) account — pick earliest reset.
+     *   2. Any healthy account — pick earliest reset. This intentionally ignores
+     *      user caps when every option is capped; limits are advisory, not a hard
+     *      ban that would leave Claude Code with no working account. The fallback
+     *      is logged via the optional onCapBypass callback so the dashboard can
+     *      surface it instead of silently exceeding the cap.
+     *   3. accounts[0] as a last resort (only if every account is unhealthy).
+     *
+     * Throws `EmptyPoolError` when there are no accounts at all — callers in
+     * the request path should map this to a 503. The DELETE endpoint guards
+     * against this state by refusing to remove the last account.
      */
     getNext() {
-        const available = this.accounts.filter(a => a.healthy && !a.busy && a.rateLimits.status !== "rate_limited");
+        if (this.accounts.length === 0) {
+            throw new EmptyPoolError("token pool is empty — add an account first");
+        }
+        const available = this.accounts.filter(a => a.healthy &&
+            !a.busy &&
+            a.rateLimits.status !== "rate_limited" &&
+            isUsable(a));
         if (available.length === 0) {
+            const healthyUsable = this.accounts.filter(a => a.healthy && isUsable(a));
+            if (healthyUsable.length > 0) {
+                return healthyUsable.reduce((best, a) => earliestReset(a) < earliestReset(best) ? a : best);
+            }
             const healthy = this.accounts.filter(a => a.healthy);
             if (healthy.length === 0) {
                 return this.accounts[0];
             }
-            // All healthy but busy/limited — pick earliest reset time
-            return healthy.reduce((best, a) => {
-                const resetA = earliestReset(a);
-                const resetBest = earliestReset(best);
-                return resetA < resetBest ? a : best;
-            });
+            // All healthy accounts are either busy, rate-limited, or over user caps.
+            // Fall back to the one that'll reset soonest — see docstring. Notify
+            // the listener so the bypass becomes visible in the dashboard.
+            const fallback = healthy.reduce((best, a) => earliestReset(a) < earliestReset(best) ? a : best);
+            const someCapped = this.accounts.some(a => a.healthy && overUserCap(a));
+            if (someCapped && this.onCapBypass) {
+                this.onCapBypass(fallback);
+            }
+            return fallback;
         }
         const account = available[this.currentIndex % available.length];
         this.currentIndex = (this.currentIndex + 1) % available.length;
@@ -37,6 +81,9 @@ export class TokenPool {
         account.lastUsed = Date.now();
         return account;
     }
+    /** Optional listener fired when a request is routed to a capped account
+     *  because every account in the pool was over its user-configured cap. */
+    onCapBypass;
     getAll() {
         return this.accounts;
     }
@@ -54,6 +101,90 @@ export class TokenPool {
             lastUsedMs: a.lastUsed,
             lastRefreshMs: a.lastRefresh,
             rateLimits: a.rateLimits,
+            enabled: a.enabled,
+            sessionLimitPercent: a.sessionLimitPercent,
+            weeklyLimitPercent: a.weeklyLimitPercent,
         }));
     }
+    // ─── Mutation API (used by the authenticated HTTP endpoints) ───────────────
+    findById(id) {
+        return this.accounts.find(a => a.id === id) ?? null;
+    }
+    /**
+     * Apply a partial update to an account's user-controlled fields.
+     * Only `enabled`, `sessionLimitPercent`, and `weeklyLimitPercent` are
+     * touched — token fields are never accepted via this API.
+     * Returns the updated account, or null if the id was not found.
+     */
+    updateAccount(id, patch) {
+        const a = this.findById(id);
+        if (!a)
+            return null;
+        if (patch.enabled !== undefined)
+            a.enabled = !!patch.enabled;
+        if (patch.sessionLimitPercent !== undefined) {
+            a.sessionLimitPercent = clampPercent(patch.sessionLimitPercent);
+        }
+        if (patch.weeklyLimitPercent !== undefined) {
+            a.weeklyLimitPercent = clampPercent(patch.weeklyLimitPercent);
+        }
+        return a;
+    }
+    /**
+     * Append a new account built from a persisted AccountRecord.
+     * Rejects duplicates by id — callers should pre-check with findById().
+     */
+    addAccount(record) {
+        if (this.findById(record.id)) {
+            throw new Error(`Account "${record.id}" already exists`);
+        }
+        const account = {
+            id: record.id,
+            tokens: {
+                accessToken: record.accessToken,
+                refreshToken: record.refreshToken,
+                expiresAt: record.expiresAt,
+                scopes: record.scopes ?? ["user:inference", "user:profile"],
+            },
+            healthy: true,
+            busy: false,
+            requestCount: 0,
+            errorCount: 0,
+            lastUsed: 0,
+            lastRefresh: 0,
+            consecutiveErrors: 0,
+            rateLimits: { ...DEFAULT_RATE_LIMITS },
+            enabled: record.enabled !== false,
+            sessionLimitPercent: record.sessionLimitPercent !== undefined
+                ? clampPercent(record.sessionLimitPercent)
+                : ACCOUNT_USER_DEFAULTS.sessionLimitPercent,
+            weeklyLimitPercent: record.weeklyLimitPercent !== undefined
+                ? clampPercent(record.weeklyLimitPercent)
+                : ACCOUNT_USER_DEFAULTS.weeklyLimitPercent,
+        };
+        this.accounts.push(account);
+        return account;
+    }
+    /**
+     * Remove an account by id. Returns true if something was removed.
+     *
+     * CRITICAL: mutates `this.accounts` IN PLACE via splice() rather than
+     * reassigning it. The server passes the same array reference to
+     * `startRefreshLoop()` at startup; reassigning would desynchronize the
+     * refresh loop from the pool, and the loop's `saveAccounts(accounts)` call
+     * would later resurrect the deleted account on disk.
+     */
+    removeAccount(id) {
+        const idx = this.accounts.findIndex(a => a.id === id);
+        if (idx === -1)
+            return false;
+        this.accounts.splice(idx, 1);
+        if (this.accounts.length > 0) {
+            this.currentIndex = this.currentIndex % this.accounts.length;
+        }
+        else {
+            this.currentIndex = 0;
+        }
+        return true;
+    }
 }

package/dist/proxy/token-refresher.js

@@ -1,4 +1,4 @@
-import { writeAccountsAtomic } from "../config/manager.js";
+import { writeAccountsAtomic, serialize } from "../config/manager.js";
 import { logRefresh } from "./logger.js";
 import { stats } from "./stats.js";
 /**
@@ -86,14 +86,7 @@ async function _doRefresh(account) {
  * Must be called after every successful refresh since refresh_token ROTATES.
  */
 export function saveAccounts(accounts) {
-    const records = accounts.map(a => ({
-        id: a.id,
-        accessToken: a.tokens.accessToken,
-        refreshToken: a.tokens.refreshToken,
-        expiresAt: a.tokens.expiresAt,
-        scopes: a.tokens.scopes,
-    }));
-    writeAccountsAtomic(records);
+    writeAccountsAtomic(serialize(accounts));
 }
 /**
  * Background refresh loop: checks every 5 minutes and refreshes any

package/dist/proxy/types.js

@@ -9,3 +9,21 @@ export const DEFAULT_RATE_LIMITS = {
     requestsLimit: 0,
     lastUpdated: 0,
 };
+/**
+ * Single source of truth for the default values of user-controllable
+ * account fields. Used by deserialize(), TokenPool.addAccount(),
+ * setupSingleAccount(), and the PATCH validation path.
+ */
+export const ACCOUNT_USER_DEFAULTS = {
+    enabled: true,
+    sessionLimitPercent: 100,
+    weeklyLimitPercent: 100,
+};
+/**
+ * Coerce any unknown value into a valid percent in [0, 100].
+ * Non-numbers, NaN, and out-of-range values collapse to the fallback (100).
+ */
+export function clampPercent(n) {
+    const v = typeof n === "number" && Number.isFinite(n) ? n : 100;
+    return Math.max(0, Math.min(100, Math.round(v)));
+}

package/dist/ui/Dashboard.js

@@ -1,6 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { useState, useEffect } from "react";
+import React, { useState, useEffect, useCallback, useRef } from "react";
 import { Box, Text, useInput, useApp } from "ink";
+import { createAccountsApi } from "./accountsApi.js";
 const POLL_INTERVAL_MS = 2_000;
 const LOG_VISIBLE = 20;
 const EMPTY_RL = {
@@ -8,21 +9,24 @@ const EMPTY_RL = {
     sevenDayUtil: 0, sevenDayReset: 0, claim: "", plan: "",
     requestsLimit: 0, lastUpdated: 0,
 };
-export function Dashboard({ port, baseUrl, authToken }) {
+export function Dashboard({ port, baseUrl, authToken, onIntent }) {
     const { exit } = useApp();
     const [data, setData] = useState(null);
     const [connectError, setConnectError] = useState(null);
     const [lastUpdate, setLastUpdate] = useState(0);
     const [retryCount, setRetryCount] = useState(0);
+    const resolvedBase = baseUrl
+        ? baseUrl.replace(/\/+$/, "")
+        : `http://localhost:${port}`;
+    const api = React.useMemo(() => createAccountsApi(resolvedBase, authToken), [resolvedBase, authToken]);
+    // Only q to quit when no live data yet (no mode to cancel)
     useInput((input, key) => {
-        if (input === "q" || key.escape)
+        if (!data && (input === "q" || key.escape))
             exit();
     });
     useEffect(() => {
         let cancelled = false;
-        const healthUrl = baseUrl
-            ? `${baseUrl.replace(/\/+$/, "")}/cc-router/health`
-            : `http://localhost:${port}/cc-router/health`;
+        const healthUrl = `${resolvedBase}/cc-router/health`;
         const headers = authToken
             ? { authorization: `Bearer ${authToken}` }
             : {};
@@ -47,77 +51,264 @@ export function Dashboard({ port, baseUrl, authToken }) {
             catch {
                 if (cancelled)
                     return;
-                setConnectError(`Cannot connect to http://localhost:${port}`);
+                setConnectError(`Cannot connect to ${resolvedBase}`);
                 setRetryCount(n => n + 1);
             }
         };
         poll();
         const timer = setInterval(poll, POLL_INTERVAL_MS);
         return () => { cancelled = true; clearInterval(timer); };
-    }, [port]);
+    }, [resolvedBase, authToken]);
     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 http://localhost:", port, "..."] }) }));
+        return (_jsx(Box, { flexDirection: "column", marginTop: 1, children: _jsxs(Text, { color: "yellow", children: ["\u280B Connecting to ", resolvedBase, "..."] }) }));
     }
-    return _jsx(LiveDashboard, { data: data, port: port, lastUpdate: lastUpdate });
+    return (_jsx(LiveDashboard, { data: data, port: port, lastUpdate: lastUpdate, api: api, onIntent: onIntent }));
 }
 // ─── 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, lastUpdate }) {
+function LiveDashboard({ data, port, lastUpdate, api, onIntent, }) {
+    const { exit } = useApp();
     const healthyCount = data.accounts.filter(a => a.healthy).length;
     const updatedAgo = Math.round((Date.now() - lastUpdate) / 1000);
     const logs = data.recentLogs;
-    // Stable selection: track by timestamp so it survives log rotations
+    // ── Focus / mode ──────────────────────────────────────────────────────────
+    const [focus, setFocus] = useState("logs");
+    const [mode, setMode] = useState("view");
+    // Selected log by timestamp (existing)
     const [selectedTs, setSelectedTs] = useState(null);
-    // Derive index from timestamp; default to 0 (newest)
-    const selectedIndex = selectedTs !== null
+    const selectedLogIndex = selectedTs !== null
         ? Math.max(0, logs.findIndex(l => l.ts === selectedTs))
         : 0;
-    useInput((_input, key) => {
-        if (key.upArrow) {
-            const next = Math.max(0, selectedIndex - 1);
-            setSelectedTs(logs[next]?.ts ?? null);
+    // Selected account by id
+    const [selectedAccountId, setSelectedAccountId] = useState(null);
+    const selectedAccountIndex = selectedAccountId !== null
+        ? Math.max(0, data.accounts.findIndex(a => a.id === selectedAccountId))
+        : 0;
+    const selectedAccount = data.accounts[selectedAccountIndex] ?? null;
+    // Inline text input state (for w / s keys)
+    const [editBuffer, setEditBuffer] = useState("");
+    // Transient banner (error or success, cleared after 4s).
+    // The timer handle is stored in a ref so new banners cancel the previous
+    // timeout and component unmount also clears it — otherwise a deferred
+    // 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) => {
+        if (bannerTimerRef.current)
+            clearTimeout(bannerTimerRef.current);
+        setBanner({ text, color });
+        bannerTimerRef.current = setTimeout(() => {
+            setBanner(null);
+            bannerTimerRef.current = null;
+        }, 4_000);
+    }, []);
+    useEffect(() => () => {
+        if (bannerTimerRef.current)
+            clearTimeout(bannerTimerRef.current);
+    }, []);
+    // Normalize any thrown value to a displayable string — rejections from
+    // fetch/AbortSignal can be DOMException without .message, strings, or
+    // even undefined.
+    const errMsg = (err) => {
+        if (err instanceof Error && err.message)
+            return err.message;
+        const s = String(err ?? "");
+        return s || "unknown error";
+    };
+    // ── Async helpers (fire-and-forget with error → banner) ──────────────────
+    const doToggleEnabled = useCallback(async () => {
+        if (!selectedAccount)
+            return;
+        const newValue = !(selectedAccount.enabled !== false);
+        try {
+            await api.patch(selectedAccount.id, { enabled: newValue });
+            showBanner(`${selectedAccount.id} → ${newValue ? "enabled" : "disabled"}`, newValue ? "green" : "yellow");
+        }
+        catch (err) {
+            showBanner(`Error: ${errMsg(err)}`, "red");
+        }
+    }, [selectedAccount, api, showBanner]);
+    const doSetLimit = useCallback(async (field, value) => {
+        if (!selectedAccount)
+            return;
+        try {
+            await api.patch(selectedAccount.id, { [field]: value });
+            const label = field === "sessionLimitPercent" ? "5h cap" : "7d cap";
+            showBanner(`${selectedAccount.id} → ${label} = ${value}%`, "green");
+        }
+        catch (err) {
+            showBanner(`Error: ${errMsg(err)}`, "red");
+        }
+    }, [selectedAccount, api, showBanner]);
+    const doDelete = useCallback(async () => {
+        if (!selectedAccount)
+            return;
+        try {
+            await api.remove(selectedAccount.id);
+            showBanner(`Removed ${selectedAccount.id}`, "yellow");
+            setSelectedAccountId(null);
+        }
+        catch (err) {
+            showBanner(`Error: ${errMsg(err)}`, "red");
+        }
+    }, [selectedAccount, api, showBanner]);
+    // ── Keyboard handler ──────────────────────────────────────────────────────
+    useInput((input, key) => {
+        // ── Text editing mode (w / s) ───────────────────────────────────────
+        if (mode === "editSession" || mode === "editWeekly") {
+            if (key.escape) {
+                setMode("view");
+                setEditBuffer("");
+                return;
+            }
+            if (key.return) {
+                const parsed = parseInt(editBuffer, 10);
+                if (!Number.isNaN(parsed) && parsed >= 0 && parsed <= 100) {
+                    const field = mode === "editSession" ? "sessionLimitPercent" : "weeklyLimitPercent";
+                    void doSetLimit(field, parsed);
+                }
+                else {
+                    showBanner("Invalid: enter a number 0–100", "red");
+                }
+                setMode("view");
+                setEditBuffer("");
+                return;
+            }
+            if (key.backspace || key.delete) {
+                setEditBuffer(b => b.slice(0, -1));
+                return;
+            }
+            if (/^[0-9]$/.test(input) && editBuffer.length < 3) {
+                setEditBuffer(b => b + input);
+            }
+            return;
         }
-        if (key.downArrow) {
-            const next = Math.min(logs.length - 1, selectedIndex + 1);
-            setSelectedTs(logs[next]?.ts ?? null);
+        // ── Confirm delete (y/n) ────────────────────────────────────────────
+        if (mode === "confirmDelete") {
+            if (input === "y" || input === "Y") {
+                void doDelete();
+                setMode("view");
+            }
+            else {
+                setMode("view");
+                showBanner("Delete cancelled", "gray");
+            }
+            return;
+        }
+        // ── Normal view mode ────────────────────────────────────────────────
+        if (input === "q") {
+            onIntent ? onIntent("quit") : exit();
+            return;
+        }
+        if (key.escape) {
+            if (focus === "accounts") {
+                setFocus("logs");
+                return;
+            }
+            onIntent ? onIntent("quit") : exit();
+            return;
+        }
+        if (key.tab) {
+            setFocus(f => f === "logs" ? "accounts" : "logs");
+            return;
+        }
+        // Navigation: ↑↓ move within the focused panel
+        if (focus === "logs") {
+            if (key.upArrow) {
+                const next = Math.max(0, selectedLogIndex - 1);
+                setSelectedTs(logs[next]?.ts ?? null);
+            }
+            if (key.downArrow) {
+                const next = Math.min(logs.length - 1, selectedLogIndex + 1);
+                setSelectedTs(logs[next]?.ts ?? null);
+            }
+        }
+        if (focus === "accounts") {
+            if (key.upArrow) {
+                const next = Math.max(0, selectedAccountIndex - 1);
+                setSelectedAccountId(data.accounts[next]?.id ?? null);
+            }
+            if (key.downArrow) {
+                const next = Math.min(data.accounts.length - 1, selectedAccountIndex + 1);
+                setSelectedAccountId(data.accounts[next]?.id ?? null);
+            }
+            // Account actions (only when focus = accounts)
+            if (input === "e") {
+                void doToggleEnabled();
+                return;
+            }
+            if (input === "w") {
+                setMode("editWeekly");
+                setEditBuffer("");
+                return;
+            }
+            if (input === "s") {
+                setMode("editSession");
+                setEditBuffer("");
+                return;
+            }
+            if (input === "d") {
+                setMode("confirmDelete");
+                return;
+            }
+        }
+        // n = add account — works regardless of focus
+        if (input === "n") {
+            if (onIntent) {
+                onIntent("addAccount");
+                exit();
+            }
+            return;
         }
     });
-    const selectedLog = logs[selectedIndex] ?? null;
+    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  [\u2191\u2193] navigate  \u00B7  [q] quit"] })] }), _jsx(Box, { marginTop: 1 }), _jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { bold: true, children: [" ACCOUNTS  ", _jsxs(Text, { color: healthyCount === data.accounts.length ? "green" : "yellow", children: [healthyCount, "/", data.accounts.length, " healthy"] })] }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: data.accounts.map(a => (_jsx(AccountRow, { account: a }, a.id))) })] }), _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
+    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 }), _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  [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: i === selectedIndex }, `${log.ts}-${i}`))) })] }), selectedLog && (_jsxs(_Fragment, { children: [_jsx(Box, { marginTop: 1 }), _jsx(DetailPanel, { log: selectedLog })] }))] }));
+                            : 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 })] }))] }));
 }
 // ─── Account row (two-line: status + utilization bars) ───────────────────────
-function AccountRow({ account: a }) {
+function AccountRow({ account: a, selected }) {
     const rl = a.rateLimits ?? EMPTY_RL;
     const isLimited = rl.status === "rate_limited";
-    const dot = isLimited ? "⊘" : a.busy ? "◌" : a.healthy ? "●" : "●";
-    const dotColor = isLimited ? "red" : a.busy ? "yellow" : a.healthy ? "green" : "red";
-    const statusLabel = isLimited ? "LIMITED" : a.busy ? "busy   " : a.healthy ? "ok     " : "ERROR  ";
-    const statusColor = isLimited ? "red" : a.busy ? "yellow" : a.healthy ? "green" : "red";
+    const isDisabled = a.enabled === false;
+    const dot = isDisabled ? "⊘" : isLimited ? "⊘" : a.busy ? "◌" : a.healthy ? "●" : "●";
+    const dotColor = isDisabled ? "gray" : isLimited ? "red" : a.busy ? "yellow" : a.healthy ? "green" : "red";
+    const statusLabel = isDisabled ? "OFF    " : isLimited ? "LIMITED" : a.busy ? "busy   " : a.healthy ? "ok     " : "ERROR  ";
+    const statusColor = isDisabled ? "gray" : isLimited ? "red" : a.busy ? "yellow" : a.healthy ? "green" : "red";
     const expiryLabel = a.expiresInMs > 0 ? formatMs(a.expiresInMs) : "EXPIRED";
     const expiryColor = a.expiresInMs < 10 * 60 * 1000 ? "red"
         : a.expiresInMs < 30 * 60 * 1000 ? "yellow"
             : "white";
     const planTag = rl.plan ? ` [${rl.plan}]` : "";
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsxs(Text, { color: dotColor, children: [" ", dot, " "] }), _jsx(Text, { children: a.id.slice(0, 20).padEnd(20) }), _jsx(Text, { color: statusColor, children: statusLabel }), planTag && _jsx(Text, { color: "magenta", children: planTag.padEnd(10) }), !planTag && _jsx(Text, { children: "".padEnd(10) }), _jsx(Text, { color: "gray", children: " req " }), _jsx(Text, { color: "white", children: String(a.requestCount).padStart(5) }), _jsx(Text, { color: "gray", children: "  err " }), _jsx(Text, { color: a.errorCount > 0 ? "red" : "gray", children: String(a.errorCount).padStart(3) }), _jsx(Text, { color: "gray", children: "  tok " }), _jsx(Text, { color: expiryColor, children: expiryLabel.padEnd(8) }), _jsx(Text, { color: "gray", children: "  last " }), _jsx(Text, { color: "gray", children: formatAgo(a.lastUsedMs) })] }), rl.lastUpdated > 0 && (_jsxs(Box, { paddingLeft: 4, children: [_jsx(UtilBar, { label: "5h", util: rl.fiveHourUtil, resetTs: rl.fiveHourReset, isActive: rl.claim === "five_hour" }), _jsx(Text, { children: "   " }), _jsx(UtilBar, { label: "7d", util: rl.sevenDayUtil, resetTs: rl.sevenDayReset, isActive: rl.claim === "seven_day" })] }))] }));
+    // User-defined caps hint
+    const s5 = a.sessionLimitPercent ?? 100;
+    const w7 = a.weeklyLimitPercent ?? 100;
+    const hasCaps = s5 < 100 || w7 < 100;
+    const capsHint = hasCaps
+        ? ` cap${s5 < 100 ? ` 5h≤${s5}%` : ""}${w7 < 100 ? ` 7d≤${w7}%` : ""}`
+        : "";
+    const pointer = selected ? "▶" : " ";
+    const nameColor = isDisabled ? "gray" : undefined;
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: selected ? "cyan" : undefined, children: pointer }), _jsxs(Text, { color: dotColor, children: [" ", dot, " "] }), _jsx(Text, { color: nameColor, dimColor: isDisabled, children: a.id.slice(0, 20).padEnd(20) }), _jsx(Text, { color: statusColor, children: statusLabel }), planTag && _jsx(Text, { color: "magenta", children: planTag.padEnd(10) }), !planTag && _jsx(Text, { children: "".padEnd(10) }), _jsx(Text, { color: "gray", children: " req " }), _jsx(Text, { color: "white", children: String(a.requestCount).padStart(5) }), _jsx(Text, { color: "gray", children: "  err " }), _jsx(Text, { color: a.errorCount > 0 ? "red" : "gray", children: String(a.errorCount).padStart(3) }), _jsx(Text, { color: "gray", children: "  tok " }), _jsx(Text, { color: expiryColor, children: expiryLabel.padEnd(8) }), _jsx(Text, { color: "gray", children: "  last " }), _jsx(Text, { color: "gray", children: formatAgo(a.lastUsedMs) }), capsHint && _jsx(Text, { color: "yellow", children: capsHint })] }), rl.lastUpdated > 0 && (_jsxs(Box, { paddingLeft: 4, children: [_jsx(UtilBar, { label: "5h", util: rl.fiveHourUtil, resetTs: rl.fiveHourReset, isActive: rl.claim === "five_hour", cap: s5 }), _jsx(Text, { children: "   " }), _jsx(UtilBar, { label: "7d", util: rl.sevenDayUtil, resetTs: rl.sevenDayReset, isActive: rl.claim === "seven_day", cap: w7 })] }))] }));
 }
 // ─── Utilization bar ─────────────────────────────────────────────────────────
-function UtilBar({ label, util, resetTs, isActive }) {
+function UtilBar({ label, util, resetTs, isActive, cap }) {
     const pct = Math.round(util * 100);
     const BAR_W = 12;
     const filled = Math.round(util * BAR_W);
+    const capPos = Math.round((cap / 100) * BAR_W);
     const bar = "█".repeat(Math.min(filled, BAR_W)) + "░".repeat(Math.max(BAR_W - filled, 0));
-    const color = pct >= 90 ? "red" : pct >= 70 ? "yellow" : "green";
+    const color = pct >= cap ? "red" : pct >= 90 ? "red" : pct >= 70 ? "yellow" : "green";
     const resetLabel = resetTs > 0 ? formatResetIn(resetTs) : "";
-    return (_jsxs(Box, { children: [_jsxs(Text, { color: isActive ? "white" : "gray", bold: isActive, children: [label, " "] }), _jsx(Text, { color: color, children: bar }), _jsxs(Text, { color: color, children: [String(pct).padStart(4), "%"] }), resetLabel && _jsxs(Text, { color: "gray", children: [" \u21BB", resetLabel] })] }));
+    const capLabel = cap < 100 ? ` cap ${cap}%` : "";
+    return (_jsxs(Box, { children: [_jsxs(Text, { color: isActive ? "white" : "gray", bold: isActive, children: [label, " "] }), _jsx(Text, { color: color, children: bar }), _jsxs(Text, { color: color, children: [String(pct).padStart(4), "%"] }), capLabel && _jsx(Text, { color: "yellow", children: capLabel }), resetLabel && _jsxs(Text, { color: "gray", children: [" \u21BB", resetLabel] })] }));
 }
 function formatResetIn(unixSeconds) {
     const diff = unixSeconds - Date.now() / 1000;
@@ -212,7 +403,6 @@ function TokenSummary({ cacheRead, cacheCreated, uncached, output }) {
     const totalAll = totalInput + output;
     if (totalAll === 0)
         return null;
-    const hitPct = totalInput > 0 ? (cacheRead / totalInput) * 100 : 0;
     return (_jsxs(Box, { paddingLeft: 2, children: [_jsx(Text, { color: "gray", children: "input " }), _jsx(Text, { color: "white", children: fmtTok(totalInput) }), _jsx(Text, { color: "gray", children: " (cached " }), _jsx(Text, { color: "green", children: fmtTok(cacheRead) }), _jsx(Text, { color: "gray", children: " + new " }), _jsx(Text, { color: "yellow", children: fmtTok(cacheCreated) }), _jsx(Text, { color: "gray", children: " + uncached " }), _jsx(Text, { color: "white", children: fmtTok(uncached) }), _jsx(Text, { color: "gray", children: ")  \u00B7  output " }), _jsx(Text, { color: "white", children: fmtTok(output) }), _jsx(Text, { color: "gray", children: "  \u00B7  total " }), _jsx(Text, { color: "cyan", bold: true, children: fmtTok(totalAll) })] }));
 }
 function fmtTok(n) {

package/dist/ui/accountsApi.js

@@ -0,0 +1,45 @@
+/**
+ * Tiny authenticated HTTP client for /cc-router/accounts.
+ *
+ * Used by the Ink dashboard to mutate account settings (enable/disable,
+ * set per-account caps, delete) without exiting the TUI. The `addAccount`
+ * flow is NOT in here — that runs inquirer and must exit Ink first; see
+ * src/cli/cmd-status.ts `runAddAccountFlow`.
+ */
+const REQUEST_TIMEOUT_MS = 3_000;
+export function createAccountsApi(baseUrl, authToken) {
+    const base = baseUrl.replace(/\/+$/, "") + "/cc-router/accounts";
+    const authHeaders = authToken
+        ? { authorization: `Bearer ${authToken}` }
+        : {};
+    async function send(method, path, body) {
+        const res = await fetch(base + path, {
+            method,
+            headers: {
+                ...authHeaders,
+                ...(body !== undefined ? { "content-type": "application/json" } : {}),
+            },
+            body: body !== undefined ? JSON.stringify(body) : undefined,
+            signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+        });
+        if (!res.ok) {
+            // Try to surface the server's error message if we can read one
+            let detail = "";
+            try {
+                const data = await res.json();
+                if (data?.error)
+                    detail = `: ${data.error}`;
+            }
+            catch { /* best effort */ }
+            throw new Error(`HTTP ${res.status}${detail}`);
+        }
+    }
+    return {
+        patch(id, patch) {
+            return send("PATCH", `/${encodeURIComponent(id)}`, patch);
+        },
+        remove(id) {
+            return send("DELETE", `/${encodeURIComponent(id)}`);
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-cc-router",
-  "version": "0.4.3",
+  "version": "0.5.0",
   "description": "Round-robin proxy for Claude Max OAuth tokens — use multiple Claude Max accounts with Claude Code",
   "type": "module",
   "bin": {