@timo972/cc-router 0.7.0

package/dist/proxy/server.js

@@ -0,0 +1,875 @@
+import express from "express";
+import { createProxyMiddleware } from "http-proxy-middleware";
+import { ServerResponse } from "http";
+import { timingSafeEqual } from "crypto";
+import { TokenPool } from "./token-pool.js";
+import { needsRefresh, refreshAccountIfCurrent, saveAccounts, startRefreshLoop } from "./token-refresher.js";
+import { loadAccounts, loadOpenAIAccounts, saveOpenAIAccounts, accountsFileExists, readAccountsFromPath, readConfig, writeConfig, getProxyRequestTimeoutMs, migrateLegacyAccountProviders, setProviderAccountsEnabled } from "../config/manager.js";
+import { checkForUpdate, performUpdate, restartSelf, printUpdateBanner } 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";
+import { stats } from "./stats.js";
+import { PROXY_PORT, LITELLM_URL } from "../config/paths.js";
+import { writePid, removePid } from "../daemon/pid.js";
+import { createOpenAIAccountPicker } from "../providers/openai/account-pool.js";
+import { prepareOpenAIAccountForRequest, startOpenAIRefreshLoop } from "../providers/openai/token-refresher.js";
+import { mountResponsesRoutes } from "./responses-server.js";
+import { mountMessagesCrossProviderRoute } from "./messages-cross-route.js";
+import { mountModelsRoute } from "./models-server.js";
+import chalk from "chalk";
+import { SessionRouter } from "./session-router.js";
+import { createAnthropicProxy } from "./anthropic-proxy.js";
+import { applyUpstreamFailureRouting, routeFailureDetails, routeReasonDetails, } from "./lease-lifecycle.js";
+import { persistProviderEnabledState } from "./provider-routing.js";
+import { accountDeletionStatusCode, deleteAnthropicAccountTransaction, } from "./account-deletion.js";
+import { createAnthropicRefreshMiddleware, createAnthropicRoutingMiddleware, } from "./anthropic-routing.js";
+import { createStreamLifecycleTracker } from "./stream-lifecycle.js";
+const zeroRoutingMetrics = () => ({
+    inFlightRequests: 0,
+    activeSessions: 0,
+    coolingDown: false,
+});
+export function createOperationalStatus(opts) {
+    const anthropicAccounts = opts.accounts.filter(a => a.provider === "anthropic_subscription");
+    const openAIAccounts = opts.accounts.filter(a => a.provider === "openai_subscription");
+    const modelRouting = opts.modelRouting ?? {};
+    return {
+        mode: opts.mode,
+        target: opts.target,
+        auth: { required: opts.authRequired },
+        providers: {
+            anthropic: providerStatus(anthropicAccounts),
+            openai: providerStatus(openAIAccounts),
+        },
+        endpoints: {
+            health: "/cc-router/health",
+            accounts: "/cc-router/accounts",
+            messages: "/v1/messages",
+            responses: "/v1/responses",
+            models: "/v1/models",
+        },
+        routing: {
+            anthropicDefaultModel: modelRouting.anthropicDefaultModel,
+            openAIDefaultModel: modelRouting.openAIDefaultModel,
+            anthropicAliases: Object.keys(modelRouting.anthropicAliases ?? {}).sort(),
+            openAIAliases: Object.keys(modelRouting.openAIAliases ?? {}).sort(),
+        },
+        capabilities: {
+            anthropicMessages: anthropicAccounts.length > 0,
+            openAIResponses: openAIAccounts.length > 0,
+            crossProviderMessages: openAIAccounts.length > 0,
+            dynamicModels: true,
+            accountManagement: true,
+        },
+    };
+}
+export function createHealthAccountViews(anthropicAccounts, openAIAccounts, resolveRoutingMetrics = zeroRoutingMetrics) {
+    return [
+        ...anthropicAccounts.map(account => (publicAnthropicAccountView(account, resolveRoutingMetrics(account.id)))),
+        ...openAIAccounts.map(publicOpenAIAccountView),
+    ];
+}
+function publicAnthropicAccountView(a, metrics) {
+    return {
+        id: a.id,
+        provider: "anthropic_subscription",
+        enabled: a.enabled,
+        sessionLimitPercent: a.sessionLimitPercent,
+        weeklyLimitPercent: a.weeklyLimitPercent,
+        healthy: a.enabled !== false && a.healthy,
+        busy: a.busy || metrics.coolingDown,
+        inFlightRequests: metrics.inFlightRequests,
+        activeSessions: metrics.activeSessions,
+        requestCount: a.requestCount,
+        errorCount: a.errorCount,
+        expiresInMs: a.tokens.expiresAt - Date.now(),
+        lastUsedMs: a.lastUsed,
+        lastRefreshMs: a.lastRefresh,
+        rateLimits: a.rateLimits,
+    };
+}
+function publicOpenAIAccountView(a) {
+    const expiresInMs = a.expiresAt - Date.now();
+    return {
+        id: a.id,
+        provider: "openai_subscription",
+        enabled: a.enabled !== false,
+        healthy: a.enabled !== false && expiresInMs > 0,
+        busy: false,
+        inFlightRequests: 0,
+        activeSessions: 0,
+        requestCount: 0,
+        errorCount: 0,
+        expiresInMs,
+        lastUsedMs: 0,
+        lastRefreshMs: 0,
+    };
+}
+function providerStatus(accounts) {
+    return {
+        configured: accounts.length > 0,
+        accounts: accounts.length,
+        healthy: accounts.filter(a => a.healthy).length,
+        enabled: accounts.filter(a => a.enabled !== false).length,
+    };
+}
+// Mutates entry and updates aggregate counters with token usage from Anthropic's
+// response. Called asynchronously after the log entry is already stored,
+// so the dashboard picks up the values on the next poll.
+function applyInputUsage(entry, usage) {
+    entry.cacheReadTokens = usage["cache_read_input_tokens"] ?? 0;
+    entry.cacheCreationTokens = usage["cache_creation_input_tokens"] ?? 0;
+    entry.inputTokens = usage["input_tokens"] ?? 0;
+    stats.totalCacheReadTokens += entry.cacheReadTokens;
+    stats.totalCacheCreationTokens += entry.cacheCreationTokens;
+    stats.totalInputTokens += entry.inputTokens;
+}
+function applyOutputUsage(entry, usage) {
+    entry.outputTokens = usage["output_tokens"] ?? 0;
+    stats.totalOutputTokens += entry.outputTokens;
+}
+// ─── Rate limit header extraction ──────────────────────────────────────────
+function inferPlan(requestsLimit) {
+    if (requestsLimit <= 0)
+        return "";
+    if (requestsLimit <= 100)
+        return "Pro";
+    if (requestsLimit <= 500)
+        return "Max 5x";
+    return "Max 20x";
+}
+function extractRateLimits(headers) {
+    const h = (name) => String(headers[name] ?? "");
+    const status = h("anthropic-ratelimit-unified-status");
+    if (!status)
+        return null; // No unified headers in this response
+    const requestsLimit = parseInt(h("anthropic-ratelimit-requests-limit"), 10) || 0;
+    return {
+        status: status === "rate_limited" ? "rate_limited" : "allowed",
+        fiveHourUtil: parseFloat(h("anthropic-ratelimit-unified-5h-utilization")) || 0,
+        fiveHourReset: parseInt(h("anthropic-ratelimit-unified-5h-reset"), 10) || 0,
+        sevenDayUtil: parseFloat(h("anthropic-ratelimit-unified-7d-utilization")) || 0,
+        sevenDayReset: parseInt(h("anthropic-ratelimit-unified-7d-reset"), 10) || 0,
+        claim: h("anthropic-ratelimit-unified-representative-claim"),
+        plan: inferPlan(requestsLimit),
+        requestsLimit,
+        lastUpdated: Date.now(),
+    };
+}
+export async function startServer(opts = {}) {
+    const port = opts.port ?? PROXY_PORT;
+    // Direct-to-Anthropic (standalone) or via LiteLLM (full mode).
+    // Priority: explicit option > LITELLM_URL env var > direct to Anthropic
+    const litellmUrl = opts.litellmUrl ?? LITELLM_URL;
+    const target = litellmUrl ?? "https://api.anthropic.com";
+    const mode = litellmUrl ? "litellm" : "standalone";
+    const accountsPath = opts.accountsPath;
+    if (!accountsFileExists(accountsPath)) {
+        console.error(chalk.red("\n✗ accounts.json not found."));
+        console.error(chalk.yellow("  Run: cc-router setup\n"));
+        process.exit(1);
+    }
+    migrateLegacyAccountProviders(accountsPath);
+    const accounts = accountsPath ? readAccountsFromPath(accountsPath) : loadAccounts();
+    const openAIAccounts = loadOpenAIAccounts(accountsPath);
+    if (accounts.length === 0 && openAIAccounts.length === 0) {
+        console.error(chalk.red("\n✗ No accounts found in accounts.json."));
+        console.error(chalk.yellow("  Run: cc-router setup\n"));
+        process.exit(1);
+    }
+    const pool = new TokenPool(accounts);
+    const sessionRouter = new SessionRouter(pool);
+    const createRoutingMetricsResolver = () => {
+        const activeSessionCounts = sessionRouter.getActiveSessionCountsSnapshot();
+        return accountId => ({
+            inFlightRequests: pool.getInFlight(accountId),
+            activeSessions: activeSessionCounts.get(accountId) ?? 0,
+            coolingDown: pool.isCoolingDown(accountId),
+        });
+    };
+    const pickOpenAIAccount = createOpenAIAccountPicker(openAIAccounts);
+    const initialConfig = readConfig();
+    const modelRouting = initialConfig.modelRouting ?? {};
+    // 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 });
+    };
+    // Surface rate-limit recovery in the dashboard so users see the account
+    // rejoin the rotation instead of wondering why it stayed red.
+    pool.onCooldownExpired = (a) => {
+        const msg = `${a.id} cooldown expired — rate limit cleared`;
+        stats.addLog({ ts: Date.now(), accountId: a.id, model: "-", type: "route", details: msg });
+    };
+    startRefreshLoop(accounts);
+    startOpenAIRefreshLoop(openAIAccounts, saveOpenAIAccounts);
+    const app = express();
+    const proxyRequestTimeoutMs = getProxyRequestTimeoutMs();
+    // ─── Proxy auth middleware ─────────────────────────────────────────────────
+    // If a proxySecret is configured, all requests must present it as EITHER
+    //   "Authorization: Bearer <secret>" (Claude Code CLI, HTTP clients)
+    //   OR "x-api-key: <secret>" (Claude Desktop via mitmproxy, Anthropic SDK)
+    // The /cc-router/health endpoint is always exempt so monitoring and PM2
+    // healthchecks keep working.
+    const { proxySecret } = initialConfig;
+    const secretBuf = proxySecret ? Buffer.from(proxySecret, "utf-8") : null;
+    // Pull the presented secret from either accepted header.
+    const presentedSecret = (req) => {
+        const auth = req.headers["authorization"] ?? "";
+        const bearerToken = auth.startsWith("Bearer ") ? auth.slice(7) : "";
+        const apiKey = req.headers["x-api-key"] ?? "";
+        return bearerToken || apiKey;
+    };
+    // Constant-time comparison with the configured secret (length pre-check is
+    // required — timingSafeEqual throws on length mismatch).
+    const secretMatches = (presented) => {
+        if (!secretBuf)
+            return false;
+        const presentedBuf = Buffer.from(presented, "utf-8");
+        return presentedBuf.length === secretBuf.length && timingSafeEqual(presentedBuf, secretBuf);
+    };
+    if (secretBuf) {
+        app.use((req, res, next) => {
+            if (req.path === "/cc-router/health")
+                return next();
+            if (!secretMatches(presentedSecret(req))) {
+                res.status(401).json({
+                    type: "error",
+                    error: { type: "authentication_error", message: "Invalid or missing proxy authentication token" },
+                });
+                return;
+            }
+            next();
+        });
+    }
+    // ─── Health endpoint (cc-router internal, NOT proxied) ────────────────────
+    // Always reachable without auth so PM2/monitoring liveness checks keep
+    // working — but the DETAILED payload (account IDs, plan tier, usage, recent
+    // request paths) is disclosure-sensitive. Return it only to an authenticated
+    // caller. When no secret is configured the server is loopback-only (enforced
+    // before app.listen), so returning full detail to localhost is acceptable.
+    app.get("/cc-router/health", (req, res) => {
+        // Sweep expired cooldowns on each poll so the dashboard reflects recovery
+        // even during idle periods when no /v1 request would trigger getNext().
+        pool.sweepExpiredCooldowns();
+        const resolveRoutingMetrics = createRoutingMetricsResolver();
+        const accountViews = createHealthAccountViews(pool.getAll(), openAIAccounts, resolveRoutingMetrics);
+        const status = accountViews.some(a => a.healthy) ? "ok" : "degraded";
+        if (secretBuf && !secretMatches(presentedSecret(req))) {
+            res.json({ status });
+            return;
+        }
+        res.json({
+            status,
+            mode,
+            target,
+            operational: createOperationalStatus({
+                mode,
+                target,
+                authRequired: Boolean(proxySecret),
+                accounts: accountViews,
+                modelRouting,
+            }),
+            uptime: stats.getUptimeSeconds(),
+            totalRequests: stats.totalRequests,
+            totalErrors: stats.totalErrors,
+            totalRefreshes: stats.totalRefreshes,
+            totalCacheReadTokens: stats.totalCacheReadTokens,
+            totalCacheCreationTokens: stats.totalCacheCreationTokens,
+            totalInputTokens: stats.totalInputTokens,
+            totalOutputTokens: stats.totalOutputTokens,
+            accounts: accountViews,
+            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.
+    accountsRouter.get("/", (_req, res) => {
+        const resolveRoutingMetrics = createRoutingMetricsResolver();
+        res.json({
+            accounts: createHealthAccountViews(pool.getAll(), openAIAccounts, resolveRoutingMetrics),
+        });
+    });
+    accountsRouter.patch("/providers/:provider", (req, res) => {
+        const providerParam = req.params.provider;
+        if (providerParam !== "anthropic_subscription" && providerParam !== "openai_subscription") {
+            res.status(400).json({ error: "provider must be anthropic_subscription or openai_subscription" });
+            return;
+        }
+        const body = (req.body ?? {});
+        if (typeof body.enabled !== "boolean") {
+            res.status(400).json({ error: "enabled must be boolean" });
+            return;
+        }
+        const enabled = body.enabled;
+        const provider = providerParam;
+        const snapshots = {
+            anthropic: pool.getAll().map(a => ({ id: a.id, enabled: a.enabled })),
+            openai: openAIAccounts.map(a => ({ id: a.id, enabled: a.enabled })),
+        };
+        const applyRuntime = (enabled) => {
+            if (provider === "anthropic_subscription") {
+                for (const account of pool.getAll()) {
+                    pool.updateAccount(account.id, { enabled });
+                }
+            }
+            else {
+                for (const account of openAIAccounts) {
+                    account.enabled = enabled;
+                }
+            }
+        };
+        const rollback = () => {
+            for (const snapshot of snapshots.anthropic) {
+                pool.updateAccount(snapshot.id, { enabled: snapshot.enabled });
+            }
+            for (const snapshot of snapshots.openai) {
+                const account = openAIAccounts.find(a => a.id === snapshot.id);
+                if (account)
+                    account.enabled = snapshot.enabled;
+            }
+        };
+        applyRuntime(enabled);
+        try {
+            const changed = persistProviderEnabledState({
+                provider,
+                enabled,
+                accountIds: pool.getAll().map(account => account.id),
+                persist: () => setProviderAccountsEnabled(provider, enabled, accountsPath),
+                invalidateAccount: accountId => sessionRouter.invalidateAccount(accountId),
+            });
+            res.json({ provider, enabled, changed });
+        }
+        catch (err) {
+            rollback();
+            const message = err instanceof Error ? err.message : String(err);
+            logError("accounts", 0, `Failed to persist provider state: ${message}`);
+            res.status(500).json({ error: `Failed to persist accounts.json: ${message}` });
+        }
+    });
+    /**
+     * 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;
+        }
+        if (patch.enabled === false)
+            sessionRouter.invalidateAccount(id);
+        res.json({
+            account: publicAnthropicAccountView(updated, createRoutingMetricsResolver()(updated.id)),
+        });
+    });
+    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: publicAnthropicAccountView(added, createRoutingMetricsResolver()(added.id)),
+        });
+    });
+    accountsRouter.delete("/:id", async (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;
+        }
+        try {
+            await deleteAnthropicAccountTransaction({
+                id,
+                pool,
+                sessionRouter,
+                persist: saveAccounts,
+            });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            const status = accountDeletionStatusCode(err);
+            if (status === 409) {
+                res.status(409).json({ error: message });
+                return;
+            }
+            logError("accounts", 0, `Failed to persist accounts.json: ${message}`);
+            res.status(500).json({ error: `Failed to persist accounts.json: ${message}` });
+            return;
+        }
+        res.json({ ok: true, id });
+    });
+    app.use("/cc-router/accounts", accountsRouter);
+    mountModelsRoute(app, {
+        getAnthropicAccounts: () => pool.getAll(),
+        getOpenAIAccounts: () => openAIAccounts,
+        getModelRouting: () => modelRouting,
+        setModelRouting: async (next) => {
+            Object.keys(modelRouting).forEach(key => {
+                delete modelRouting[key];
+            });
+            Object.assign(modelRouting, next);
+            writeConfig({ ...readConfig(), modelRouting: next });
+        },
+        prepareOpenAIAccount: (account) => prepareOpenAIAccountForRequest(account, openAIAccounts, saveOpenAIAccounts),
+    });
+    mountResponsesRoutes(app, {
+        getOpenAIAccount: pickOpenAIAccount,
+        prepareOpenAIAccount: (account) => prepareOpenAIAccountForRequest(account, openAIAccounts, saveOpenAIAccounts),
+        modelRouting,
+    });
+    mountMessagesCrossProviderRoute(app, {
+        getOpenAIAccount: pickOpenAIAccount,
+        prepareOpenAIAccount: (account) => prepareOpenAIAccountForRequest(account, openAIAccounts, saveOpenAIAccounts),
+        modelRouting,
+    });
+    // ─── Proxy middleware ──────────────────────────────────────────────────────
+    // IMPORTANT: selfHandleResponse must be false (default) for SSE streaming to
+    // work transparently. Setting it to true breaks streaming.
+    const proxy = createAnthropicProxy({
+        target,
+        timeoutMs: proxyRequestTimeoutMs,
+        on: {
+            proxyReq: (proxyReq, req) => {
+                const account = req._ccAccount;
+                if (!account)
+                    return;
+                // Replace the placeholder/proxy auth token with the real OAuth token.
+                // Claude Code sends ANTHROPIC_AUTH_TOKEN as "Authorization: Bearer proxy-managed".
+                // We replace it with the real OAuth token for this account.
+                proxyReq.setHeader("authorization", `Bearer ${account.tokens.accessToken}`);
+                // Remove x-api-key if present — OAuth authentication uses Authorization Bearer,
+                // not x-api-key. Having both set can cause conflicts at Anthropic's side.
+                proxyReq.removeHeader("x-api-key");
+                // CRITICAL: api.anthropic.com requires the "oauth-2025-04-20" beta flag to
+                // accept OAuth tokens (sk-ant-oat01-*). Without it the request is rejected
+                // with "OAuth authentication is currently not supported."
+                // APPEND — do NOT replace — so existing betas (tools, computer-use, etc.) are preserved.
+                const existingBeta = proxyReq.getHeader("anthropic-beta");
+                const betas = existingBeta
+                    ? String(existingBeta).split(",").map(b => b.trim()).filter(Boolean)
+                    : [];
+                if (!betas.includes("oauth-2025-04-20")) {
+                    betas.push("oauth-2025-04-20");
+                    proxyReq.setHeader("anthropic-beta", betas.join(","));
+                }
+                // All other headers are forwarded automatically by http-proxy-middleware:
+                //   anthropic-version         — required by Anthropic API
+                //   X-Claude-Code-Session-Id  — session aggregation header sent by Claude Code
+                //   content-type              — always application/json
+                if (req._ccRawBody) {
+                    proxyReq.setHeader("content-length", Buffer.byteLength(req._ccRawBody));
+                    proxyReq.write(req._ccRawBody);
+                }
+            },
+            proxyRes: (proxyRes, req, response) => {
+                const account = req._ccAccount;
+                const route = req._ccRoute;
+                if (!account)
+                    return;
+                const status = proxyRes.statusCode ?? 0;
+                const durationMs = req._startTime
+                    ? Date.now() - req._startTime
+                    : undefined;
+                // Complete the pending log entry with response info
+                const pendingLog = req._pendingLog ?? {
+                    ts: Date.now(),
+                    accountId: account.id,
+                    model: "-",
+                    type: "route",
+                };
+                pendingLog.statusCode = status;
+                if (durationMs !== undefined)
+                    pendingLog.durationMs = durationMs;
+                const cooldownSeconds = route
+                    ? applyUpstreamFailureRouting(status, proxyRes.headers["retry-after"], route, sessionRouter, pool)
+                    : undefined;
+                if (status === 401) {
+                    // Token invalid or expired mid-request.
+                    // Forward the 401 to the client (Claude Code will retry on 401).
+                    // Schedule a background refresh so the next request succeeds.
+                    stats.totalErrors++;
+                    account.errorCount++;
+                    pendingLog.type = "error";
+                    pendingLog.details = route
+                        ? routeFailureDetails(route, "token-invalid")
+                        : "token-invalid";
+                    logError(account.id, 401, "Token invalid — scheduling background refresh");
+                    void refreshAccountIfCurrent(account, pool).catch(console.error);
+                }
+                else if (status === 429) {
+                    // Rate limited — put account on cooldown for Retry-After seconds.
+                    stats.totalErrors++;
+                    account.errorCount++;
+                    const retryAfter = cooldownSeconds ?? 60;
+                    pendingLog.type = "error";
+                    pendingLog.details = route
+                        ? routeFailureDetails(route, "rate-limited")
+                        : "rate-limited";
+                    logError(account.id, 429, `Rate limited — cooldown ${retryAfter}s`);
+                }
+                else if (status === 529) {
+                    // Anthropic service overloaded — short cooldown on this account.
+                    stats.totalErrors++;
+                    account.errorCount++;
+                    pendingLog.type = "error";
+                    pendingLog.details = route
+                        ? routeFailureDetails(route, "service-overloaded")
+                        : "service-overloaded";
+                    logError(account.id, 529, "Service overloaded — cooldown 30s");
+                }
+                // ── Capture rate limit utilization from response headers ────────────
+                const rl = extractRateLimits(proxyRes.headers);
+                if (rl)
+                    account.rateLimits = rl;
+                const entry = pendingLog;
+                stats.addLog(entry);
+                // ── Capture token usage from Anthropic response body ─────────────────
+                // SSE streams carry usage across two events:
+                //   message_start  → input_tokens, cache_read/creation_input_tokens
+                //   message_delta   → output_tokens
+                // Non-streaming JSON carries all fields in a single usage object.
+                // We use incremental line parsing (not buffering) so we can capture
+                // both events without holding the full stream in memory.
+                const contentType = String(proxyRes.headers["content-type"] ?? "");
+                const encoding = String(proxyRes.headers["content-encoding"] ?? "");
+                const isCompressed = /gzip|br|deflate/.test(encoding);
+                const streamTracker = createStreamLifecycleTracker(req._startTime ?? Date.now(), !isCompressed && contentType.includes("text/event-stream"));
+                entry.streamLifecycle = streamTracker.state;
+                streamTracker.attach(proxyRes, response);
+                proxyRes.on("data", (chunk) => streamTracker.observeChunk(chunk));
+                if (!isCompressed && (contentType.includes("text/event-stream") || contentType.includes("application/json"))) {
+                    const isSSE = contentType.includes("text/event-stream");
+                    if (isSSE) {
+                        let lineBuf = "";
+                        let gotInput = false;
+                        let gotOutput = false;
+                        proxyRes.on("data", (chunk) => {
+                            if (gotInput && gotOutput)
+                                return;
+                            lineBuf += chunk.toString("utf8");
+                            const lines = lineBuf.split("\n");
+                            lineBuf = lines.pop() ?? ""; // keep incomplete last line
+                            for (const line of lines) {
+                                if (!line.startsWith("data: "))
+                                    continue;
+                                try {
+                                    const evt = JSON.parse(line.slice(6));
+                                    if (!gotInput && evt.type === "message_start" && evt.message?.usage) {
+                                        applyInputUsage(entry, evt.message.usage);
+                                        gotInput = true;
+                                    }
+                                    if (!gotOutput && evt.type === "message_delta" && evt.usage) {
+                                        applyOutputUsage(entry, evt.usage);
+                                        gotOutput = true;
+                                    }
+                                }
+                                catch { /* partial JSON across chunk boundary — next chunk will complete it */ }
+                            }
+                        });
+                    }
+                    else {
+                        // Non-streaming JSON: buffer full body then parse once
+                        let buf = "";
+                        proxyRes.on("data", (chunk) => { buf += chunk.toString("utf8"); });
+                        proxyRes.on("end", () => {
+                            try {
+                                const body = JSON.parse(buf);
+                                if (body.usage) {
+                                    applyInputUsage(entry, body.usage);
+                                    applyOutputUsage(entry, body.usage);
+                                }
+                            }
+                            catch { /* ignore */ }
+                        });
+                    }
+                }
+            },
+            error: (err, _req, res) => {
+                const request = _req;
+                request._ccReleaseLease?.();
+                stats.totalErrors++;
+                logError("proxy", 0, err.message);
+                // Complete the pending log entry for connection-level errors
+                const pendingLog = request._pendingLog;
+                if (pendingLog) {
+                    pendingLog.type = "error";
+                    pendingLog.statusCode = 0;
+                    pendingLog.details = request._ccRoute
+                        ? routeFailureDetails(request._ccRoute, "proxy-error")
+                        : "proxy-error";
+                    if (request._startTime) {
+                        pendingLog.durationMs = Date.now() - request._startTime;
+                    }
+                    stats.addLog(pendingLog);
+                }
+                // res may be a Socket (WebSocket upgrade) — only respond on HTTP ServerResponse
+                if (res instanceof ServerResponse && !res.headersSent) {
+                    // Match Anthropic's error response format so Claude Code handles it gracefully
+                    res.writeHead(502, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({
+                        type: "error",
+                        error: { type: "proxy_error", message: err.message },
+                    }));
+                }
+            },
+        },
+    });
+    // ─── /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", createAnthropicRoutingMiddleware({
+        sessionRouter,
+        onEmptyPool: (err, _req, res) => {
+            stats.totalErrors++;
+            logError("proxy", 503, err.message);
+            res.status(503).json({
+                type: "error",
+                error: { type: "no_accounts", message: err.message },
+            });
+        },
+    }), createAnthropicRefreshMiddleware({
+        needsRefresh,
+        refresh: account => refreshAccountIfCurrent(account, pool),
+        onRefreshFailure: (account) => {
+            stats.totalErrors++;
+            logError(account.id, 401, "Token refresh failed");
+        },
+    }), (req, _res, next) => {
+        const route = req._ccRoute;
+        const account = route.account;
+        req._startTime = Date.now();
+        const source = route.sessionId !== undefined
+            ? "cli"
+            : req.headers["x-api-key"]
+                ? "desktop"
+                : "api";
+        req._pendingLog = {
+            ts: Date.now(),
+            accountId: account.id,
+            model: "-",
+            type: "route",
+            method: req.method,
+            path: req.path,
+            source,
+            details: routeReasonDetails(route),
+        };
+        stats.totalRequests++;
+        logRoute(account.id, account.requestCount, Math.round((account.tokens.expiresAt - Date.now()) / 60_000));
+        next();
+    }, proxy);
+    // ─── Catch-all — forward everything else (LiteLLM UI, /v1/models, etc.) ──
+    app.use("/", createProxyMiddleware({
+        target,
+        changeOrigin: true,
+    }));
+    // ─── Graceful shutdown ────────────────────────────────────────────────────
+    const shutdown = () => {
+        console.log(chalk.yellow("\nShutting down — saving tokens..."));
+        saveAccounts(pool.getAll());
+        if (process.env["CC_ROUTER_DAEMON"] === "1") {
+            removePid();
+        }
+        process.exit(0);
+    };
+    process.on("SIGTERM", shutdown);
+    process.on("SIGINT", shutdown);
+    // ─── Update handling ──────────────────────────────────────────────────────
+    // Auto-update is OFF by default: installing code unattended from the npm
+    // registry (no signature/provenance check) turns any publish-channel
+    // compromise into RCE across every running proxy. Default behaviour is
+    // notify-only, like pip/npm. Opt in explicitly with `autoUpdate: true` in
+    // config or CC_ROUTER_AUTO_UPDATE=1.
+    const cfg = readConfig();
+    const autoUpdate = (cfg.autoUpdate === true || process.env["CC_ROUTER_AUTO_UPDATE"] === "1") &&
+        process.env["CC_ROUTER_NO_AUTO_UPDATE"] !== "1";
+    if (autoUpdate) {
+        const AUTO_UPDATE_INTERVAL = 6 * 60 * 60 * 1000; // 6 hours
+        const runAutoUpdate = async () => {
+            try {
+                const check = await checkForUpdate();
+                if (!check.updateAvailable || check.diff === "major")
+                    return;
+                console.log(chalk.cyan(`[auto-update] v${check.current} → v${check.latest} (${check.diff})`));
+                const ok = await performUpdate(check.latest);
+                if (ok) {
+                    console.log(chalk.green("[auto-update] Restarting with new version..."));
+                    saveAccounts(pool.getAll());
+                    restartSelf();
+                }
+            }
+            catch (err) {
+                console.error(chalk.gray(`[auto-update] Check failed: ${err.message}`));
+            }
+        };
+        // First check 60s after startup, then every 6h
+        setTimeout(runAutoUpdate, 60_000).unref();
+        setInterval(runAutoUpdate, AUTO_UPDATE_INTERVAL).unref();
+    }
+    else {
+        // Notify-only: a single background check shortly after startup. Never
+        // installs — just prints the banner telling the user how to update.
+        setTimeout(() => {
+            void checkForUpdate()
+                .then(printUpdateBanner)
+                .catch(() => { });
+        }, 60_000).unref();
+    }
+    // ─── Start ────────────────────────────────────────────────────────────────
+    // HOST env var lets teams bind to 0.0.0.0 for LAN/VPS shared access.
+    // Defaults to 127.0.0.1 (localhost-only) for single-user safety.
+    const host = process.env["HOST"] ?? "127.0.0.1";
+    // Hard safety net: never expose the proxy on a non-loopback interface without
+    // a secret. Every start path funnels through app.listen(host), so this guards
+    // the daemon / service / HOST=0.0.0.0 cases the interactive wizard can't.
+    const isLoopbackHost = (h) => h === "127.0.0.1" || h === "::1" || h === "localhost" || h === "::ffff:127.0.0.1";
+    if (!isLoopbackHost(host) && !proxySecret) {
+        console.error(chalk.red(`\n✗ Refusing to bind ${host}:${port} without a proxy secret.\n` +
+            `  Exposing the proxy to the network without authentication would let\n` +
+            `  anyone who can reach it use your Claude/OpenAI accounts.\n` +
+            `  Fix: run 'cc-router start' and set a password when asked, or add a\n` +
+            `  "proxySecret" to ~/.cc-router/config.json. To bind localhost only,\n` +
+            `  unset HOST (or set HOST=127.0.0.1).\n`));
+        process.exit(1);
+    }
+    app.listen(port, host, () => {
+        // Write PID for daemon/service process management
+        if (process.env["CC_ROUTER_DAEMON"] === "1") {
+            writePid(process.pid);
+        }
+        const totalAccountCount = accounts.length + openAIAccounts.length;
+        logStartup(port, host, mode, target, {
+            anthropic: accounts.length,
+            openai: openAIAccounts.length,
+        });
+        console.log(autoUpdate
+            ? chalk.gray("  Auto-update: enabled (patch/minor)")
+            : chalk.gray("  Auto-update: off (notify-only) — run 'cc-router update' to install"));
+        // Anonymous telemetry — fire-and-forget, never blocks proxy startup.
+        try {
+            const telemetryState = loadTelemetryState();
+            // First-run detection: if the install is brand new, emit app_started too
+            const firstRunAge = Date.now() - new Date(telemetryState.firstRunAt).getTime();
+            if (firstRunAge < 5 * 60 * 1000) {
+                void trackEvent("app_started", { first_run: true });
+            }
+            void trackEvent("proxy_started", {
+                account_count: totalAccountCount,
+                mode,
+            });
+            startHeartbeat(totalAccountCount);
+        }
+        catch {
+            // never let telemetry break the proxy
+        }
+    });
+}