ai-cc-router 0.1.0

package/dist/cli/cmd-docker.js

@@ -0,0 +1,140 @@
+import { execFile, spawn } from "child_process";
+import { promisify } from "util";
+import { existsSync } from "fs";
+import { join } from "path";
+import { fileURLToPath } from "url";
+import { dirname } from "path";
+import chalk from "chalk";
+import { ACCOUNTS_PATH, LITELLM_PORT, PROXY_PORT } from "../config/paths.js";
+const execFileAsync = promisify(execFile);
+const __filename = fileURLToPath(import.meta.url);
+const COMPOSE_FILE = join(dirname(__filename), "..", "..", "docker-compose.yml");
+export function registerDocker(program) {
+    const docker = program
+        .command("docker")
+        .description("Manage the full Docker stack (cc-router + LiteLLM)");
+    docker
+        .command("up")
+        .description("Start cc-router + LiteLLM with Docker Compose")
+        .option("--build", "Rebuild the cc-router image before starting")
+        .action(async (opts) => {
+        await ensureDockerAvailable();
+        await ensureAccountsExist();
+        console.log(chalk.cyan("\nStarting cc-router + LiteLLM via Docker Compose...\n"));
+        const args = ["compose", "-f", COMPOSE_FILE, "up", "-d"];
+        if (opts.build)
+            args.push("--build");
+        try {
+            await spawnInherited("docker", args);
+            await waitForHealthy();
+            printDockerInfo();
+        }
+        catch (err) {
+            console.error(chalk.red("\n✗ docker compose up failed:"), err.message);
+            console.error(chalk.gray("  Check logs with: cc-router docker logs"));
+            process.exit(1);
+        }
+    });
+    docker
+        .command("down")
+        .description("Stop and remove Docker containers")
+        .option("-v, --volumes", "Also remove named volumes")
+        .action(async (opts) => {
+        const args = ["compose", "-f", COMPOSE_FILE, "down"];
+        if (opts.volumes)
+            args.push("-v");
+        await spawnInherited("docker", args);
+        console.log(chalk.green("\n✓ Containers stopped.\n"));
+    });
+    docker
+        .command("logs")
+        .description("Tail Docker Compose logs")
+        .option("-f, --follow", "Follow log output", true)
+        .option("--service <name>", "Show logs for a specific service (cc-router or litellm)")
+        .action(async (opts) => {
+        const args = ["compose", "-f", COMPOSE_FILE, "logs"];
+        if (opts.follow)
+            args.push("-f");
+        args.push("--tail=100");
+        if (opts.service)
+            args.push(opts.service);
+        await spawnInherited("docker", args);
+    });
+    docker
+        .command("ps")
+        .description("Show running container status")
+        .action(async () => {
+        await spawnInherited("docker", ["compose", "-f", COMPOSE_FILE, "ps"]);
+    });
+    docker
+        .command("restart")
+        .description("Restart a service without rebuilding")
+        .argument("[service]", "Service to restart (cc-router or litellm)", "cc-router")
+        .action(async (service) => {
+        await spawnInherited("docker", ["compose", "-f", COMPOSE_FILE, "restart", service]);
+        console.log(chalk.green(`\n✓ ${service} restarted.\n`));
+    });
+}
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+async function ensureDockerAvailable() {
+    try {
+        await execFileAsync("docker", ["info"]);
+    }
+    catch {
+        console.error(chalk.red("✗ Docker is not running or not installed."));
+        console.error(chalk.gray("  Install Docker Desktop: https://docs.docker.com/get-docker/"));
+        process.exit(1);
+    }
+}
+async function ensureAccountsExist() {
+    if (!existsSync(ACCOUNTS_PATH)) {
+        console.error(chalk.red(`✗ accounts.json not found at ${ACCOUNTS_PATH}`));
+        console.error(chalk.yellow("  Run: cc-router setup"));
+        process.exit(1);
+    }
+}
+/** Wait until the cc-router health endpoint responds OK (max 60s) */
+async function waitForHealthy() {
+    process.stdout.write(chalk.gray("  Waiting for services to be healthy"));
+    const deadline = Date.now() + 60_000;
+    while (Date.now() < deadline) {
+        try {
+            const res = await fetch(`http://localhost:${PROXY_PORT}/cc-router/health`, {
+                signal: AbortSignal.timeout(1_000),
+            });
+            if (res.ok) {
+                console.log(chalk.green(" ✓"));
+                return;
+            }
+        }
+        catch {
+            // not ready yet
+        }
+        process.stdout.write(".");
+        await sleep(2_000);
+    }
+    console.log(chalk.yellow(" timed out"));
+    console.log(chalk.gray("  Services may still be starting. Check: cc-router docker ps"));
+}
+function printDockerInfo() {
+    console.log(chalk.bold("\n  Stack is running:\n"));
+    console.log(`  Proxy:      ${chalk.cyan(`http://localhost:${PROXY_PORT}`)}`);
+    console.log(`  LiteLLM UI: ${chalk.cyan(`http://localhost:${LITELLM_PORT}/ui`)}`);
+    console.log(`  Health:     ${chalk.cyan(`http://localhost:${PROXY_PORT}/cc-router/health`)}`);
+    console.log();
+    console.log(chalk.gray("  Logs:   cc-router docker logs"));
+    console.log(chalk.gray("  Stop:   cc-router docker down\n"));
+}
+/** Spawn a command with inherited stdio (user sees output in real time) */
+function spawnInherited(cmd, args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(cmd, args, { stdio: "inherit" });
+        child.on("error", reject);
+        child.on("close", code => {
+            code === 0 ? resolve() : reject(new Error(`exited with code ${code}`));
+        });
+    });
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}

package/dist/cli/cmd-service.js

@@ -0,0 +1,193 @@
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { fileURLToPath } from "url";
+import { join, dirname } from "path";
+import chalk from "chalk";
+import { detectPlatform } from "../utils/platform.js";
+const execFileAsync = promisify(execFile);
+// Resolve the path to the compiled CLI entry point
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const CLI_ENTRY = join(__dirname, "index.js");
+export function registerService(program) {
+    const service = program
+        .command("service")
+        .description("Manage cc-router as a system service (auto-start on boot via PM2)");
+    service
+        .command("install")
+        .description("Register cc-router to start automatically on system boot")
+        .action(async () => {
+        console.log(chalk.cyan("\nInstalling cc-router as a system service...\n"));
+        // 1. Verify PM2 is installed
+        const pm2Version = await getPm2Version();
+        if (!pm2Version) {
+            console.log(chalk.yellow("PM2 not found. Installing globally..."));
+            try {
+                await execFileAsync("npm", ["install", "-g", "pm2"]);
+                console.log(chalk.green("✓ PM2 installed"));
+            }
+            catch (err) {
+                console.error(chalk.red("✗ Failed to install PM2:"), err.message);
+                console.error(chalk.gray("  Try manually: npm install -g pm2"));
+                process.exit(1);
+            }
+        }
+        else {
+            console.log(chalk.green(`✓ PM2 ${pm2Version} found`));
+        }
+        // 2. Register cc-router in PM2
+        console.log(chalk.gray("\nRegistering cc-router in PM2..."));
+        try {
+            await execFileAsync("pm2", [
+                "start", CLI_ENTRY,
+                "--name", "cc-router",
+                "--interpreter", process.execPath,
+                "--max-memory-restart", "500M", // restart if memory exceeds 500MB
+                "--",
+                "start",
+            ]);
+            console.log(chalk.green("✓ cc-router registered in PM2"));
+        }
+        catch (err) {
+            const msg = err.message;
+            // PM2 may already have the process — try restart instead
+            if (msg.includes("already")) {
+                await execFileAsync("pm2", ["restart", "cc-router"]);
+                console.log(chalk.green("✓ cc-router restarted in PM2"));
+            }
+            else {
+                console.error(chalk.red("✗ Failed to start in PM2:"), msg);
+                process.exit(1);
+            }
+        }
+        // 3. Save process list so it survives reboots
+        await execFileAsync("pm2", ["save"]);
+        console.log(chalk.green("✓ PM2 process list saved"));
+        // 4. Generate and apply startup hook
+        console.log(chalk.gray("\nConfiguring system startup hook..."));
+        console.log(chalk.gray("(may ask for your password on Linux/macOS)\n"));
+        try {
+            const { stdout, stderr } = await execFileAsync("pm2", ["startup"]);
+            const output = stdout + stderr;
+            // PM2 prints a sudo command to run if it can't apply it automatically
+            const sudoMatch = output.match(/sudo\s+.+/);
+            if (sudoMatch) {
+                console.log(chalk.yellow("Run this command to complete startup registration:"));
+                console.log(chalk.white(`  ${sudoMatch[0]}`));
+                console.log(chalk.gray("\nThen run:  pm2 save"));
+            }
+            else {
+                console.log(chalk.green("✓ System startup hook configured"));
+            }
+        }
+        catch (err) {
+            const msg = err;
+            const combined = (msg.stdout ?? "") + (msg.stderr ?? "");
+            const sudoMatch = combined.match(/sudo\s+.+/);
+            if (sudoMatch) {
+                console.log(chalk.yellow("\nRun this command to complete startup registration:"));
+                console.log(chalk.white(`  ${sudoMatch[0]}`));
+                console.log(chalk.gray("\nThen run:  pm2 save"));
+            }
+            else {
+                console.log(chalk.yellow("⚠ Could not configure startup hook automatically."));
+                printManualStartupInstructions();
+            }
+        }
+        printServiceInfo();
+    });
+    service
+        .command("uninstall")
+        .description("Remove cc-router from system startup")
+        .action(async () => {
+        let removed = false;
+        try {
+            await execFileAsync("pm2", ["stop", "cc-router"]);
+            await execFileAsync("pm2", ["delete", "cc-router"]);
+            await execFileAsync("pm2", ["save"]);
+            console.log(chalk.green("✓ cc-router removed from PM2"));
+            removed = true;
+        }
+        catch {
+            console.log(chalk.gray("cc-router was not registered in PM2."));
+        }
+        // Remove Claude Code proxy config too
+        const { removeClaudeSettings } = await import("../utils/claude-config.js");
+        const { readClaudeProxySettings } = await import("../utils/claude-config.js");
+        if (readClaudeProxySettings().baseUrl) {
+            removeClaudeSettings();
+            console.log(chalk.green("✓ Removed proxy settings from ~/.claude/settings.json"));
+            removed = true;
+        }
+        if (removed) {
+            console.log(chalk.green("\n✓ Service uninstalled. Claude Code will use normal authentication.\n"));
+        }
+        else {
+            console.log(chalk.gray("\nNothing to uninstall.\n"));
+        }
+    });
+    service
+        .command("status")
+        .description("Show the service status in PM2")
+        .action(async () => {
+        try {
+            const { stdout } = await execFileAsync("pm2", ["info", "cc-router"]);
+            console.log(stdout);
+        }
+        catch {
+            console.log(chalk.yellow("cc-router is not registered as a PM2 service."));
+            console.log(chalk.gray("  Install it with: cc-router service install"));
+        }
+    });
+    service
+        .command("logs")
+        .description("Tail the proxy logs from PM2")
+        .option("--lines <n>", "Number of lines to show", "50")
+        .action(async (opts) => {
+        try {
+            // pm2 logs streams continuously — spawn it directly so it inherits stdio
+            const { spawn } = await import("child_process");
+            const child = spawn("pm2", ["logs", "cc-router", "--lines", opts.lines], {
+                stdio: "inherit",
+            });
+            child.on("error", () => {
+                console.log(chalk.yellow("PM2 not found. Is cc-router installed as a service?"));
+            });
+        }
+        catch {
+            console.error(chalk.red("Could not tail logs."));
+        }
+    });
+}
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+async function getPm2Version() {
+    try {
+        const { stdout } = await execFileAsync("pm2", ["--version"]);
+        return stdout.trim();
+    }
+    catch {
+        return null;
+    }
+}
+function printServiceInfo() {
+    console.log(chalk.bold("\n━━━ Service installed ━━━━━━━━━━━━━━━━━━━━━━━━\n"));
+    console.log(`  Check status:   ${chalk.cyan("cc-router service status")}`);
+    console.log(`  View logs:      ${chalk.cyan("cc-router service logs")}`);
+    console.log(`  Stop & remove:  ${chalk.cyan("cc-router service uninstall")}`);
+    console.log(`  Restart:        ${chalk.cyan("pm2 restart cc-router")}`);
+    console.log();
+}
+function printManualStartupInstructions() {
+    const platform = detectPlatform();
+    console.log(chalk.gray("\n  To configure auto-start manually:"));
+    if (platform === "macos") {
+        console.log(chalk.gray("  macOS (launchd): pm2 startup launchd && pm2 save"));
+    }
+    else if (platform === "linux") {
+        console.log(chalk.gray("  Linux (systemd): pm2 startup systemd && pm2 save"));
+        console.log(chalk.gray("  Then: sudo systemctl enable pm2-$(whoami)"));
+    }
+    else {
+        console.log(chalk.gray("  Windows: see https://github.com/jessety/pm2-installer"));
+    }
+}

package/dist/cli/cmd-setup.js

@@ -0,0 +1,248 @@
+import { select, input, confirm, password } from "@inquirer/prompts";
+import chalk from "chalk";
+import { detectPlatform, isMacos } from "../utils/platform.js";
+import { extractFromKeychain, extractFromCredentialsFile, formatExpiry, redactToken, } from "../utils/token-extractor.js";
+import { validateToken } from "../utils/token-validator.js";
+import { writeClaudeSettings } from "../utils/claude-config.js";
+import { saveAccounts, } from "../proxy/token-refresher.js";
+import { loadAccounts, accountsFileExists } from "../config/manager.js";
+import { PROXY_PORT } from "../config/paths.js";
+// ─── Public registration ──────────────────────────────────────────────────────
+export function registerSetup(program) {
+    program
+        .command("setup")
+        .description("Interactive wizard: extract tokens and configure Claude Code automatically")
+        .option("--add", "Add a new account to an existing configuration (skip intro questions)")
+        .action(async (opts) => {
+        await runSetupWizard({ addMode: opts.add ?? false });
+    });
+}
+// ─── Shared single-account setup (also used by `accounts add`) ───────────────
+export async function setupSingleAccount(index) {
+    const platform = detectPlatform();
+    const choices = [];
+    if (isMacos()) {
+        choices.push({ name: "Extract automatically from macOS Keychain  (recommended)", value: "keychain" });
+    }
+    choices.push({ name: "Read from ~/.claude/.credentials.json", value: "credentials" });
+    choices.push({ name: "Paste tokens manually", value: "manual" });
+    const method = await select({
+        message: "How do you want to add the tokens?",
+        choices,
+    });
+    let tokens = null;
+    if (method === "keychain") {
+        process.stdout.write(chalk.gray("  Extracting from Keychain... "));
+        tokens = await extractFromKeychain();
+        if (tokens) {
+            console.log(chalk.green("✓"));
+            console.log(chalk.gray(`  Token: ${redactToken(tokens.accessToken)}`));
+            console.log(chalk.gray(`  Expiry: ${formatExpiry(tokens.expiresAt)}`));
+        }
+        else {
+            console.log(chalk.red("✗"));
+            console.log(chalk.yellow("  Could not find credentials in Keychain."));
+            console.log(chalk.gray("  Make sure Claude Code is logged in: run `claude login` first."));
+            const retry = await confirm({ message: "Try another extraction method?", default: true });
+            if (!retry)
+                return null;
+            return setupSingleAccount(index);
+        }
+    }
+    if (method === "credentials") {
+        tokens = extractFromCredentialsFile();
+        if (tokens) {
+            console.log(chalk.green(`  ✓ Found credentials in ~/.claude/.credentials.json`));
+            console.log(chalk.gray(`    Token: ${redactToken(tokens.accessToken)}`));
+            console.log(chalk.gray(`    Expiry: ${formatExpiry(tokens.expiresAt)}`));
+        }
+        else {
+            console.log(chalk.red("  ✗ ~/.claude/.credentials.json not found or unreadable."));
+            console.log(chalk.gray("  Make sure Claude Code is installed and you've run `claude login`."));
+            const retry = await confirm({ message: "Paste tokens manually instead?", default: true });
+            if (!retry)
+                return null;
+            tokens = await promptManualTokens();
+        }
+    }
+    if (method === "manual") {
+        tokens = await promptManualTokens();
+    }
+    if (!tokens)
+        return null;
+    // Ask for account ID
+    const defaultId = `max-account-${index}`;
+    const accountId = await input({
+        message: "Account ID (press Enter to accept default):",
+        default: defaultId,
+        validate: (v) => /^[a-zA-Z0-9_-]+$/.test(v) || "Only letters, numbers, _ and - allowed",
+    });
+    // Validate tokens against Anthropic API
+    process.stdout.write(chalk.gray("  Validating tokens against Anthropic... "));
+    const validation = await validateToken(tokens.accessToken);
+    if (validation.valid) {
+        console.log(chalk.green("✓ Valid"));
+    }
+    else {
+        console.log(chalk.red("✗ Invalid"));
+        console.log(chalk.yellow(`  Reason: ${validation.reason}`));
+        console.log(chalk.gray("  The token will be saved but may not work until refreshed."));
+        const keepAnyway = await confirm({
+            message: "Save this account anyway?",
+            default: false,
+        });
+        if (!keepAnyway)
+            return null;
+    }
+    return {
+        id: accountId,
+        tokens,
+        healthy: validation.valid,
+        busy: false,
+        requestCount: 0,
+        errorCount: 0,
+        lastUsed: 0,
+        lastRefresh: 0,
+        consecutiveErrors: 0,
+    };
+}
+// ─── Full wizard ──────────────────────────────────────────────────────────────
+async function runSetupWizard({ addMode }) {
+    const platform = detectPlatform();
+    const hasExisting = accountsFileExists();
+    printBanner();
+    console.log(chalk.gray(`Platform: ${platform}\n`));
+    // If accounts already exist and we're not in add-mode, ask what to do
+    if (hasExisting && !addMode) {
+        const existing = loadAccounts();
+        console.log(chalk.yellow(`  Found ${existing.length} existing account(s).\n`));
+        const action = await select({
+            message: "What do you want to do?",
+            choices: [
+                { name: "Add more accounts to the existing configuration", value: "add" },
+                { name: "Start fresh (replace all accounts)", value: "replace" },
+                { name: "Cancel", value: "cancel" },
+            ],
+        });
+        if (action === "cancel") {
+            console.log(chalk.gray("\nCancelled.\n"));
+            return;
+        }
+        if (action === "replace") {
+            const sure = await confirm({
+                message: chalk.red("This will delete all existing accounts. Are you sure?"),
+                default: false,
+            });
+            if (!sure) {
+                console.log(chalk.gray("\nCancelled.\n"));
+                return;
+            }
+        }
+        // If 'add', we'll merge below
+    }
+    // Guide for multi-account setup
+    if (!addMode && isMacos()) {
+        console.log(chalk.cyan("  Tip: to add multiple accounts, you need to:"));
+        console.log(chalk.gray("  1. Log in to Claude Code with account 1 (already done if you use CC normally)"));
+        console.log(chalk.gray("  2. Extract tokens → log out → log in with account 2 → extract → repeat\n"));
+    }
+    let numAccounts = 1;
+    if (!addMode) {
+        const { number } = await import("@inquirer/prompts");
+        numAccounts = await number({
+            message: "How many accounts do you want to configure now?",
+            default: 1,
+            min: 1,
+            max: 20,
+        }) ?? 1;
+    }
+    const newAccounts = [];
+    for (let i = 0; i < numAccounts; i++) {
+        const label = numAccounts > 1 ? `${i + 1}/${numAccounts}` : "";
+        console.log(chalk.bold(`\n${"━".repeat(40)}\n  Account ${label}\n${"━".repeat(40)}\n`));
+        // If on macOS and this isn't the first account, remind user to switch accounts
+        if (i > 0 && isMacos()) {
+            console.log(chalk.yellow(`  Before extracting account ${i + 1}:\n` +
+                `  1. Run: ${chalk.white("claude logout")}\n` +
+                `  2. Run: ${chalk.white("claude login")}  (log in with your next Max account)\n`));
+            await confirm({ message: "Ready?", default: true });
+        }
+        const account = await setupSingleAccount(i + 1 + (hasExisting ? loadAccounts().length : 0));
+        if (account) {
+            newAccounts.push(account);
+            console.log(chalk.green(`\n  ✓ Account "${account.id}" ready.\n`));
+        }
+        else {
+            console.log(chalk.yellow(`  ↷ Skipped account ${i + 1}.\n`));
+        }
+    }
+    if (newAccounts.length === 0) {
+        console.log(chalk.red("\n✗ No accounts configured. Run cc-router setup again.\n"));
+        return;
+    }
+    // Merge with existing accounts (by ID — new entries win on conflict)
+    const existing = hasExisting && !addMode ? [] : (hasExisting ? loadAccounts() : []);
+    const existingIds = new Set(existing.map(a => a.id));
+    const merged = [
+        ...existing.filter(a => !newAccounts.some(n => n.id === a.id)),
+        ...newAccounts,
+    ];
+    console.log(chalk.bold(`\n${"━".repeat(40)}\n  Saving configuration\n${"━".repeat(40)}\n`));
+    // Save accounts.json (atomic write)
+    saveAccounts(merged);
+    console.log(chalk.green(`  ✓ Saved ${merged.length} account(s) to ~/.cc-router/accounts.json`));
+    // Write ~/.claude/settings.json
+    writeClaudeSettings(PROXY_PORT);
+    console.log(chalk.green(`  ✓ Updated ~/.claude/settings.json`));
+    console.log(chalk.gray(`      ANTHROPIC_BASE_URL = http://localhost:${PROXY_PORT}`));
+    console.log(chalk.gray(`      ANTHROPIC_AUTH_TOKEN = proxy-managed`));
+    printNextSteps(merged.length);
+}
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+async function promptManualTokens() {
+    console.log(chalk.gray("\n  You can find your tokens by running:\n" +
+        "    macOS:         security find-generic-password -s 'Claude Code-credentials' -w\n" +
+        "    Linux/Windows: cat ~/.claude/.credentials.json\n"));
+    const accessToken = await password({
+        message: "Paste accessToken (sk-ant-oat01-...):",
+        mask: "•",
+        validate: (v) => v.startsWith("sk-ant-oat01-") || v.startsWith("sk-ant-")
+            ? true
+            : "Must start with sk-ant-oat01-",
+    });
+    const refreshToken = await password({
+        message: "Paste refreshToken (sk-ant-ort01-...):",
+        mask: "•",
+        validate: (v) => v.startsWith("sk-ant-ort01-") || v.startsWith("sk-ant-")
+            ? true
+            : "Must start with sk-ant-ort01-",
+    });
+    // expiresAt is optional — default to 8h from now
+    const useDefaultExpiry = await confirm({
+        message: "Use default expiry (8 hours from now)?",
+        default: true,
+    });
+    const expiresAt = useDefaultExpiry
+        ? Date.now() + 8 * 60 * 60 * 1000
+        : new Date(await input({
+            message: "Paste expiresAt (ISO date or ms timestamp):",
+        })).getTime();
+    return {
+        accessToken,
+        refreshToken,
+        expiresAt,
+        scopes: ["user:inference", "user:profile"],
+    };
+}
+function printBanner() {
+    console.log(chalk.cyan("\n╔══════════════════════════════════════════╗\n" +
+        "║  CC-Router — Setup                       ║\n" +
+        "╚══════════════════════════════════════════╝\n"));
+}
+function printNextSteps(accountCount) {
+    console.log(chalk.bold(`\n${"━".repeat(40)}\n  Done — ${accountCount} account(s) configured\n${"━".repeat(40)}\n`));
+    console.log(`  Start proxy:       ${chalk.cyan("cc-router start")}`);
+    console.log(`  Auto-start:        ${chalk.cyan("cc-router service install")}`);
+    console.log(`  Live dashboard:    ${chalk.cyan("cc-router status")}`);
+    console.log(`  Add more accounts: ${chalk.cyan("cc-router setup --add")}\n`);
+}

package/dist/cli/cmd-start.js

@@ -0,0 +1,80 @@
+import { execFile } from "child_process";
+import { promisify } from "util";
+import chalk from "chalk";
+import { PROXY_PORT, LITELLM_PORT, ACCOUNTS_PATH } from "../config/paths.js";
+const execFileAsync = promisify(execFile);
+export function registerStart(program) {
+    program
+        .command("start")
+        .description("Start the proxy server")
+        .option("--port <port>", "Port to listen on", String(PROXY_PORT))
+        .option("--daemon", "Run in background via PM2 (requires: cc-router service install)")
+        .option("--litellm [url]", "Forward to LiteLLM instead of Anthropic directly (default URL: http://localhost:4000)")
+        .option("--accounts <path>", "Path to accounts.json", ACCOUNTS_PATH)
+        .action(async (opts) => {
+        if (opts.daemon) {
+            await startDaemon();
+            return;
+        }
+        const litellmUrl = opts.litellm
+            ? (typeof opts.litellm === "string" ? opts.litellm : `http://localhost:${LITELLM_PORT}`)
+            : undefined;
+        // If --litellm is set and no URL is provided, try to start LiteLLM via Docker
+        if (opts.litellm && typeof opts.litellm !== "string") {
+            await ensureLiteLLMRunning();
+        }
+        const { startServer } = await import("../proxy/server.js");
+        await startServer({
+            port: parseInt(opts.port, 10),
+            litellmUrl,
+            accountsPath: opts.accounts !== ACCOUNTS_PATH ? opts.accounts : undefined,
+        });
+    });
+}
+async function startDaemon() {
+    try {
+        await execFileAsync("pm2", ["restart", "cc-router"]);
+        console.log(chalk.green("✓ cc-router restarted via PM2"));
+    }
+    catch {
+        console.error(chalk.red("✗ cc-router is not registered as a PM2 service."));
+        console.error(chalk.gray("  Set it up first: cc-router service install"));
+        process.exit(1);
+    }
+}
+/** Start only the LiteLLM container if it's not already responding */
+async function ensureLiteLLMRunning() {
+    const litellmUrl = `http://localhost:${LITELLM_PORT}`;
+    try {
+        const res = await fetch(`${litellmUrl}/health`, { signal: AbortSignal.timeout(1_000) });
+        if (res.ok) {
+            console.log(chalk.green(`✓ LiteLLM already running at ${litellmUrl}`));
+            return;
+        }
+    }
+    catch {
+        // Not running — start it
+    }
+    console.log(chalk.cyan("Starting LiteLLM via Docker..."));
+    try {
+        await execFileAsync("docker", ["info"]);
+    }
+    catch {
+        console.error(chalk.red("✗ Docker is not running. Start Docker Desktop first."));
+        console.error(chalk.gray("  Or pass a custom LiteLLM URL: cc-router start --litellm http://your-host:4000"));
+        process.exit(1);
+    }
+    try {
+        const { spawn } = await import("child_process");
+        await new Promise((resolve, reject) => {
+            const child = spawn("docker", ["compose", "up", "-d", "litellm"], { stdio: "inherit" });
+            child.on("error", reject);
+            child.on("close", code => code === 0 ? resolve() : reject(new Error(`exit ${code}`)));
+        });
+        console.log(chalk.green(`✓ LiteLLM starting at ${litellmUrl}/ui`));
+    }
+    catch (err) {
+        console.error(chalk.red("✗ Failed to start LiteLLM:"), err.message);
+        process.exit(1);
+    }
+}