ai-cc-router 0.2.0 → 0.2.2

package/dist/cli/cmd-client.js

@@ -16,7 +16,7 @@ function isClaudeDesktopInstalled() {
     }
     return false;
 }
-async function testRemoteConnection(url, secret) {
+async function fetchRemoteHealth(url, secret) {
     try {
         const headers = {};
         if (secret)
@@ -28,12 +28,37 @@ async function testRemoteConnection(url, secret) {
         if (!res.ok)
             return { ok: false, error: `HTTP ${res.status}` };
         const data = (await res.json());
-        return { ok: data.status === "ok" || data.status === "degraded", accounts: data.accounts?.length };
+        return { ok: data.status === "ok" || data.status === "degraded", data };
     }
     catch (e) {
         return { ok: false, error: e.message };
     }
 }
+function formatUptime(seconds) {
+    if (!seconds || seconds < 0)
+        return "0s";
+    const h = Math.floor(seconds / 3600);
+    const m = Math.floor((seconds % 3600) / 60);
+    const s = Math.floor(seconds % 60);
+    if (h > 0)
+        return `${h}h ${m}m`;
+    if (m > 0)
+        return `${m}m ${s}s`;
+    return `${s}s`;
+}
+function formatNumber(n) {
+    if (n === undefined || n === null)
+        return "0";
+    if (n >= 1_000_000)
+        return `${(n / 1_000_000).toFixed(1)}M`;
+    if (n >= 1_000)
+        return `${(n / 1_000).toFixed(1)}k`;
+    return String(n);
+}
+function formatTime(ts) {
+    const d = new Date(ts);
+    return d.toLocaleTimeString(undefined, { hour12: false });
+}
 function formatUrl(raw) {
     let url = raw.trim().replace(/\/+$/, "");
     if (!url.startsWith("http://") && !url.startsWith("https://")) {
@@ -68,14 +93,14 @@ export function registerClient(program) {
         }
         // 3. Test connection
         console.log(chalk.gray(`\nTesting connection to ${url}...`));
-        const test = await testRemoteConnection(url, secret);
+        const test = await fetchRemoteHealth(url, secret);
         if (!test.ok) {
             console.error(chalk.red(`\n✗ Cannot reach CC-Router at ${url}`));
             console.error(chalk.yellow(`  Error: ${test.error}`));
             console.error(chalk.gray("  Make sure the server is running and accessible.\n"));
             process.exit(1);
         }
-        console.log(chalk.green(`✓ Connected — ${test.accounts ?? "?"} accounts on server\n`));
+        console.log(chalk.green(`✓ Connected — ${test.data?.accounts?.length ?? "?"} accounts on server\n`));
         // 4. Save client config
         const cfg = readConfig();
         const clientCfg = { remoteUrl: url };
@@ -122,8 +147,9 @@ export function registerClient(program) {
     // ── cc-router client status ─────────────────────────────────────────────────
     client
         .command("status")
-        .description("Show client connection status")
-        .action(async () => {
+        .description("Show client connection status with live stats from the remote")
+        .option("--json", "Output raw remote health JSON")
+        .action(async (opts) => {
         const cfg = readConfig();
         const claude = readClaudeProxySettings();
         if (!cfg.client) {
@@ -131,27 +157,69 @@ export function registerClient(program) {
             console.log(chalk.gray("  Run: cc-router client connect <url>\n"));
             return;
         }
+        // Fetch live health from remote
+        const test = await fetchRemoteHealth(cfg.client.remoteUrl, cfg.client.remoteSecret);
+        if (opts.json) {
+            console.log(JSON.stringify(test.data ?? { error: test.error }, null, 2));
+            return;
+        }
         console.log(chalk.bold("\n📡 CC-Router Client Status\n"));
         console.log(`  Remote:   ${chalk.cyan(cfg.client.remoteUrl)}`);
         console.log(`  Auth:     ${cfg.client.remoteSecret ? chalk.green("secret configured") : chalk.gray("no auth")}`);
         console.log(`  Claude:   ${claude.baseUrl ? chalk.green(claude.baseUrl) : chalk.red("not configured")}`);
-        // Ping remote
-        const test = await testRemoteConnection(cfg.client.remoteUrl, cfg.client.remoteSecret);
-        if (test.ok) {
-            console.log(`  Server:   ${chalk.green("online")} (${test.accounts} accounts)`);
+        if (!test.ok) {
+            console.log(`  Server:   ${chalk.red("unreachable")} — ${test.error}`);
+            console.log(chalk.gray("\n  The remote proxy isn't responding. Your requests may be failing."));
+            console.log();
+            return;
+        }
+        const d = test.data;
+        console.log(`  Server:   ${chalk.green("online")}  ·  up ${chalk.gray(formatUptime(d.uptime ?? 0))}`);
+        // ── Totals ─────────────────────────────────────────────────────────
+        console.log(chalk.bold("\n  TOTALS"));
+        console.log(`    Requests: ${chalk.cyan(formatNumber(d.totalRequests))}` +
+            `   Errors: ${((d.totalErrors ?? 0) > 0 ? chalk.red : chalk.gray)(formatNumber(d.totalErrors))}`);
+        console.log(`    Input:    ${chalk.gray(formatNumber(d.totalInputTokens))} tok` +
+            `   Output: ${chalk.gray(formatNumber(d.totalOutputTokens))} tok` +
+            `   Cache read: ${chalk.gray(formatNumber(d.totalCacheReadTokens))} tok`);
+        // ── Accounts ───────────────────────────────────────────────────────
+        if (d.accounts && d.accounts.length > 0) {
+            console.log(chalk.bold("\n  ACCOUNTS"));
+            for (const a of d.accounts) {
+                const dot = a.healthy ? chalk.green("●") : chalk.red("●");
+                console.log(`    ${dot} ${a.id.padEnd(20)}  req ${String(a.requestCount ?? 0).padStart(5)}  ` +
+                    `err ${String(a.errorCount ?? 0).padStart(3)}`);
+            }
+        }
+        // ── Recent activity ────────────────────────────────────────────────
+        if (d.recentLogs && d.recentLogs.length > 0) {
+            console.log(chalk.bold("\n  RECENT ACTIVITY  (last 5)"));
+            for (const log of d.recentLogs.slice(0, 5)) {
+                const status = log.statusCode ?? 0;
+                const statusColor = status >= 500 || status === 0 ? chalk.red : status >= 400 ? chalk.yellow : chalk.green;
+                const duration = log.durationMs ? ` ${chalk.gray(log.durationMs + "ms")}` : "";
+                console.log(`    ${chalk.gray(formatTime(log.ts))}  ${log.accountId.padEnd(18)}  ` +
+                    `${(log.method ?? "?").padEnd(5)} ${(log.path ?? "?").padEnd(22)}  ` +
+                    `${statusColor(String(status))}${duration}`);
+            }
         }
         else {
-            console.log(`  Server:   ${chalk.red("unreachable")} — ${test.error}`);
+            console.log(chalk.gray("\n  No recent activity on the remote proxy."));
         }
-        // Desktop status
+        // ── Desktop status ─────────────────────────────────────────────────
+        console.log(chalk.bold("\n  DESKTOP INTERCEPTOR"));
         if (cfg.client.desktopEnabled) {
             const running = await isInterceptorRunning();
-            console.log(`  Desktop:  ${running ? chalk.green("intercepting") : chalk.yellow("configured but not running")}`);
+            console.log(`    ${running ? chalk.green("● running") : chalk.yellow("○ configured but stopped")}`);
+            if (!running) {
+                console.log(chalk.gray("    Start with: cc-router client start-desktop"));
+            }
         }
         else {
-            console.log(`  Desktop:  ${chalk.gray("not configured")}`);
+            console.log(`    ${chalk.gray("not configured")}`);
         }
         console.log();
+        console.log(chalk.gray("  Live dashboard: cc-router status\n"));
     });
     // ── cc-router client start-desktop ──────────────────────────────────────────
     client

package/dist/cli/cmd-status.js

@@ -1,5 +1,23 @@
 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() {
+    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 { healthUrl: `http://localhost:${PROXY_PORT}/cc-router/health`, headers: {} };
+}
 export function registerStatus(program) {
     program
         .command("status")
@@ -16,8 +34,10 @@ export function registerStatus(program) {
     });
 }
 async function jsonOutput(port) {
+    const { healthUrl, headers } = resolveTarget();
     try {
-        const res = await fetch(`http://localhost:${port}/cc-router/health`, {
+        const res = await fetch(healthUrl, {
+            headers,
             signal: AbortSignal.timeout(2_000),
         });
         if (!res.ok) {
@@ -27,19 +47,26 @@ async function jsonOutput(port) {
         console.log(JSON.stringify(await res.json(), null, 2));
     }
     catch {
-        console.error(chalk.red(`Cannot connect to proxy at http://localhost:${port}`));
-        console.error(chalk.gray("Is it running? Start with: cc-router start"));
+        console.error(chalk.red(`Cannot connect to proxy at ${healthUrl}`));
+        const cfg = readConfig();
+        if (cfg.client) {
+            console.error(chalk.gray("Is the remote CC-Router running?"));
+        }
+        else {
+            console.error(chalk.gray("Is it running? Start with: cc-router start"));
+        }
         process.exit(1);
     }
 }
 async function launchDashboard(port) {
+    const { baseUrl, authToken } = resolveTarget();
     // 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 }), {
+    render(createElement(Dashboard, { port, baseUrl, authToken }), {
         // Let Ink handle Ctrl+C — it calls exit() which cleanly unmounts
         exitOnCtrlC: true,
     });

package/dist/interceptor/mitmproxy-manager.js

@@ -136,7 +136,7 @@ export function writeAddonScript(target) {
         writeFileSync(ADDON_PATH, src, "utf-8");
     }
     else {
-        // Inline fallback — minimal addon
+        // Inline fallback — minimal addon (only redirects /v1/messages and /v1/models)
         const script = `
 import os
 from mitmproxy import http
@@ -144,10 +144,13 @@ from urllib.parse import urlparse
 
 _target = os.environ.get("CC_ROUTER_TARGET", ${JSON.stringify(target)}).rstrip("/")
 _p = urlparse(_target)
+_REDIRECT_PREFIXES = ("/v1/messages", "/v1/models")
 
 def request(flow: http.HTTPFlow) -> None:
     if flow.request.pretty_host != "api.anthropic.com":
         return
+    if not flow.request.path.startswith(_REDIRECT_PREFIXES):
+        return
     flow.request.scheme = _p.scheme
     flow.request.host = _p.hostname or "localhost"
     flow.request.port = _p.port or (443 if _p.scheme == "https" else 80)

package/dist/ui/Dashboard.js

@@ -8,8 +8,7 @@ const EMPTY_RL = {
     sevenDayUtil: 0, sevenDayReset: 0, claim: "", plan: "",
     requestsLimit: 0, lastUpdated: 0,
 };
-// ─── Dashboard component ──────────────────────────────────────────────────────
-export function Dashboard({ port }) {
+export function Dashboard({ port, baseUrl, authToken }) {
     const { exit } = useApp();
     const [data, setData] = useState(null);
     const [connectError, setConnectError] = useState(null);
@@ -21,9 +20,16 @@ export function Dashboard({ port }) {
     });
     useEffect(() => {
         let cancelled = false;
+        const healthUrl = baseUrl
+            ? `${baseUrl.replace(/\/+$/, "")}/cc-router/health`
+            : `http://localhost:${port}/cc-router/health`;
+        const headers = authToken
+            ? { authorization: `Bearer ${authToken}` }
+            : {};
         const poll = async () => {
             try {
-                const res = await fetch(`http://localhost:${port}/cc-router/health`, {
+                const res = await fetch(healthUrl, {
+                    headers,
                     signal: AbortSignal.timeout(1_500),
                 });
                 if (cancelled)

package/package.json

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

package/src/interceptor/addon.py

@@ -1,11 +1,16 @@
-# mitmproxy addon — redirects api.anthropic.com traffic to CC-Router.
+# mitmproxy addon — redirects ONLY /v1/messages traffic to CC-Router.
 #
-# Installed and launched by `cc-router client start-desktop`.
-# Target URL comes from the CC_ROUTER_TARGET env var (set by the launcher).
+# Claude Desktop sends many types of requests to api.anthropic.com:
+#   /v1/messages         → LLM inference (this is what we redirect)
+#   /v1/messages/count_tokens → token counting (redirect too)
+#   /v1/oauth/*          → session auth (must NOT redirect)
+#   /v1/environments/*   → bridge/cowork (must NOT redirect)
+#   /v1/models           → model listing (redirect — CC-Router proxies this)
+#   /api/*               → desktop features (must NOT redirect)
 #
-# Why not set the target as a script argument: mitmproxy's addon loader
-# does not pass argv through reliably, and env vars give us a single
-# unambiguous channel that survives the spawn boundary.
+# Only /v1/messages* and /v1/models are safe to redirect because CC-Router
+# injects its own OAuth token. Everything else carries the user's own
+# session token for features CC-Router doesn't handle.
 
 import os
 from urllib.parse import urlparse
@@ -16,22 +21,27 @@ _target_raw = os.environ.get("CC_ROUTER_TARGET", "http://localhost:3456")
 _target = _target_raw.rstrip("/")
 _target_parsed = urlparse(_target)
 
-# Fail closed on boot if the target is unusable — better than silently
-# forwarding to a broken URL and seeing Claude Desktop timeout.
 if not _target_parsed.scheme or not _target_parsed.netloc:
     raise RuntimeError(f"CC_ROUTER_TARGET is not a valid URL: {_target_raw!r}")
 
+# Paths that CC-Router can handle (it injects its own OAuth token)
+_REDIRECT_PREFIXES = (
+    "/v1/messages",
+    "/v1/models",
+)
+
 
 def request(flow: http.HTTPFlow) -> None:
     if flow.request.pretty_host != "api.anthropic.com":
         return
 
-    # Preserve path + query (e.g. /v1/messages?beta=oauth-2025-04-20)
-    # and swap only the scheme + host.
+    # Only redirect inference and model-listing paths
+    if not flow.request.path.startswith(_REDIRECT_PREFIXES):
+        return
+
     flow.request.scheme = _target_parsed.scheme
     flow.request.host = _target_parsed.hostname or "localhost"
     flow.request.port = _target_parsed.port or (443 if _target_parsed.scheme == "https" else 80)
-    # Rewrite the Host header so CC-Router sees itself, not api.anthropic.com.
     flow.request.headers["host"] = flow.request.host + (
         f":{flow.request.port}"
         if flow.request.port not in (80, 443)