@timo972/cc-router 0.7.0

package/dist/cli/cmd-configure.js

@@ -0,0 +1,145 @@
+import chalk from "chalk";
+import { writeClaudeSettings, removeClaudeSettings, readClaudeProxySettings } from "../utils/claude-config.js";
+import { writeCodexRouterConfig } from "../utils/codex-config.js";
+import { readConfig, writeConfig, generateProxySecret } from "../config/manager.js";
+import { PROXY_PORT, CLAUDE_SETTINGS_PATH } from "../config/paths.js";
+import { buildModelRoutingUpdate } from "../protocol/model-routing-config.js";
+export function registerConfigure(program) {
+    program
+        .command("configure")
+        .description("Configure Claude Code or Codex to point to the proxy")
+        .argument("[target]", "Optional target to configure: codex, models")
+        .option("--remove", "Remove cc-router settings from ~/.claude/settings.json")
+        .option("--port <port>", "Proxy port to configure", String(PROXY_PORT))
+        .option("--model <model>", "Default model for the configured target")
+        .option("--claude-model <model>", "Default Claude/Anthropic model for router aliases")
+        .option("--openai-model <model>", "Default OpenAI/Codex model for router aliases")
+        .option("--show", "Show current Claude Code proxy settings")
+        .option("--generate-password", "Generate a new proxy secret and sync Claude Code settings")
+        .option("--set-password <secret>", "Set a specific proxy secret and sync Claude Code settings")
+        .option("--remove-password", "Remove proxy password protection (open access)")
+        .option("--enable-auto-update", "Enable automatic updates for the proxy")
+        .option("--disable-auto-update", "Disable automatic updates for the proxy")
+        .action((target, opts) => {
+        if (target === "codex") {
+            const port = parseInt(opts.port, 10);
+            const result = writeCodexRouterConfig({
+                baseUrl: `http://localhost:${port}/v1`,
+                tokenEnvKey: "CC_ROUTER_TOKEN",
+                defaultModel: opts.model,
+            });
+            console.log(chalk.green(`✓ Updated ${result.path}`));
+            console.log(chalk.gray("  CODEX provider configured:"));
+            if (opts.model)
+                console.log(chalk.gray(`    model          = ${opts.model}`));
+            console.log(chalk.gray("    model_provider = cc-router"));
+            console.log(chalk.gray(`    base_url       = http://localhost:${port}/v1`));
+            console.log(chalk.gray("    env_key        = CC_ROUTER_TOKEN"));
+            return;
+        }
+        if (target === "models") {
+            if (!opts.claudeModel && !opts.openaiModel) {
+                console.error(chalk.red("Provide at least one model: --claude-model or --openai-model"));
+                process.exit(1);
+            }
+            const cfg = readConfig();
+            const modelRouting = buildModelRoutingUpdate(cfg.modelRouting, {
+                claudeModel: opts.claudeModel,
+                openAIModel: opts.openaiModel,
+            });
+            writeConfig({ ...cfg, modelRouting });
+            console.log(chalk.green("✓ Updated model routing defaults."));
+            if (opts.claudeModel)
+                console.log(chalk.gray(`  Claude default: ${opts.claudeModel}`));
+            if (opts.openaiModel)
+                console.log(chalk.gray(`  OpenAI default: ${opts.openaiModel.replace(/^openai\//, "")}`));
+            console.log(chalk.gray("  Restart cc-router for the change to affect running traffic."));
+            return;
+        }
+        if (target !== undefined) {
+            console.error(chalk.red(`Unknown configure target: ${target}`));
+            process.exit(1);
+        }
+        if (opts.show) {
+            const current = readClaudeProxySettings();
+            if (current.baseUrl) {
+                console.log(chalk.green("  Claude Code is configured to use cc-router:"));
+                console.log(`    ANTHROPIC_BASE_URL  = ${chalk.cyan(current.baseUrl)}`);
+                console.log(`    ANTHROPIC_AUTH_TOKEN = ${chalk.gray(current.authToken ?? "(not set)")}`);
+            }
+            else {
+                console.log(chalk.yellow("  Claude Code is NOT configured to use cc-router."));
+                console.log(chalk.gray(`  Run: cc-router configure`));
+            }
+            const cfg = readConfig();
+            const pwStatus = cfg.proxySecret ? chalk.green("yes") : chalk.gray("no");
+            const autoUpdateEnabled = cfg.autoUpdate !== false;
+            const auStatus = autoUpdateEnabled ? chalk.green("enabled") : chalk.gray("disabled");
+            console.log(`    Password protected:  ${pwStatus}`);
+            console.log(`    Auto-update:         ${auStatus}`);
+            return;
+        }
+        if (opts.enableAutoUpdate) {
+            writeConfig({ ...readConfig(), autoUpdate: true });
+            console.log(chalk.green("✓ Auto-update enabled."));
+            console.log(chalk.gray("  The proxy will check for updates every 6h and install patch/minor releases."));
+            console.log(chalk.gray("  Restart cc-router for the change to take effect."));
+            return;
+        }
+        if (opts.disableAutoUpdate) {
+            writeConfig({ ...readConfig(), autoUpdate: false });
+            console.log(chalk.green("✓ Auto-update disabled."));
+            console.log(chalk.gray("  Use `cc-router update` to update manually."));
+            console.log(chalk.gray("  Restart cc-router for the change to take effect."));
+            return;
+        }
+        if (opts.remove) {
+            removeClaudeSettings();
+            console.log(chalk.green("✓ Removed cc-router settings from ~/.claude/settings.json"));
+            console.log(chalk.gray("  Claude Code will use its default authentication on next launch."));
+            return;
+        }
+        if (opts.generatePassword) {
+            const secret = generateProxySecret();
+            writeConfig({ ...readConfig(), proxySecret: secret });
+            const { baseUrl } = readClaudeProxySettings();
+            writeClaudeSettings(parseInt(opts.port, 10), baseUrl);
+            console.log(chalk.green("✓ Proxy password set."));
+            console.log("  " + chalk.bold.yellow("Save this — it will not be shown again:"));
+            console.log("  " + chalk.bold(secret));
+            console.log(chalk.gray("  Restart cc-router for the change to take effect."));
+            return;
+        }
+        if (opts.setPassword !== undefined) {
+            const secret = opts.setPassword.trim();
+            if (!secret) {
+                console.error(chalk.red("Secret cannot be empty."));
+                process.exit(1);
+            }
+            writeConfig({ ...readConfig(), proxySecret: secret });
+            const { baseUrl } = readClaudeProxySettings();
+            writeClaudeSettings(parseInt(opts.port, 10), baseUrl);
+            console.log(chalk.green("✓ Proxy password updated."));
+            console.log(chalk.gray("  Restart cc-router for the change to take effect."));
+            return;
+        }
+        if (opts.removePassword) {
+            const cfg = readConfig();
+            delete cfg.proxySecret;
+            writeConfig(cfg);
+            const { baseUrl } = readClaudeProxySettings();
+            writeClaudeSettings(parseInt(opts.port, 10), baseUrl);
+            console.log(chalk.green("✓ Proxy password removed. Access is now open."));
+            console.log(chalk.gray("  Restart cc-router for the change to take effect."));
+            return;
+        }
+        const port = parseInt(opts.port, 10);
+        writeClaudeSettings(port, undefined, undefined, opts.model);
+        const { proxySecret } = readConfig();
+        console.log(chalk.green(`✓ Updated ${CLAUDE_SETTINGS_PATH}`));
+        if (opts.model)
+            console.log(chalk.gray(`  model                = ${opts.model}`));
+        console.log(chalk.gray(`  ANTHROPIC_BASE_URL  = http://localhost:${port}`));
+        console.log(chalk.gray(`  ANTHROPIC_AUTH_TOKEN = ${proxySecret ? chalk.green("(secret configured)") : "proxy-managed"}`));
+    });
+}

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-logs.js

@@ -0,0 +1,85 @@
+import { existsSync, openSync, readSync, closeSync, statSync, watch } from "fs";
+import chalk from "chalk";
+import { LOG_PATH } from "../config/paths.js";
+export function registerLogs(program) {
+    program
+        .command("logs")
+        .description("View proxy logs")
+        .option("--lines <n>", "Number of lines to show (default: 50)", "50")
+        .option("-f, --follow", "Follow log output in real time")
+        .action(async (opts) => {
+        if (!existsSync(LOG_PATH)) {
+            console.log(chalk.yellow("No log file found."));
+            console.log(chalk.gray(`  Expected: ${LOG_PATH}`));
+            console.log(chalk.gray("  Logs are created when running in background mode."));
+            console.log(chalk.gray("  Foreground mode prints directly to this terminal.\n"));
+            return;
+        }
+        const numLines = parseInt(opts.lines, 10) || 50;
+        if (opts.follow) {
+            await tailFollow(numLines);
+        }
+        else {
+            tailStatic(numLines);
+        }
+    });
+}
+/** Print last N lines of the log file using byte-based seeking. */
+function tailStatic(n) {
+    if (!existsSync(LOG_PATH)) {
+        console.log(chalk.gray("No log file found. Is the daemon running?"));
+        return;
+    }
+    const stats = statSync(LOG_PATH);
+    if (stats.size === 0) {
+        console.log(chalk.gray("Log file is empty."));
+        return;
+    }
+    // Read last chunk (up to 64KB should be enough for most tail operations)
+    const CHUNK = Math.min(stats.size, 64 * 1024);
+    const buf = Buffer.alloc(CHUNK);
+    const fd = openSync(LOG_PATH, "r");
+    readSync(fd, buf, 0, CHUNK, stats.size - CHUNK);
+    closeSync(fd);
+    const text = buf.toString("utf-8");
+    const lines = text.split("\n");
+    // Remove first potentially partial line if we didn't read from start
+    if (CHUNK < stats.size)
+        lines.shift();
+    const tail = lines.slice(-n).join("\n");
+    if (tail)
+        process.stdout.write(tail + "\n");
+}
+/** Stream log file and print new lines as they appear. */
+async function tailFollow(initialLines) {
+    // Show initial tail
+    tailStatic(initialLines);
+    console.log(chalk.gray("\n── Following log output (Ctrl+C to stop) ──\n"));
+    if (!existsSync(LOG_PATH)) {
+        console.log(chalk.gray("Waiting for log file..."));
+    }
+    let bytePosition = existsSync(LOG_PATH) ? statSync(LOG_PATH).size : 0;
+    const watcher = watch(LOG_PATH, () => {
+        try {
+            const currentSize = statSync(LOG_PATH).size;
+            if (currentSize > bytePosition) {
+                const buf = Buffer.alloc(currentSize - bytePosition);
+                const fd = openSync(LOG_PATH, "r");
+                readSync(fd, buf, 0, buf.length, bytePosition);
+                closeSync(fd);
+                process.stdout.write(buf.toString("utf-8"));
+                bytePosition = currentSize;
+            }
+            else if (currentSize < bytePosition) {
+                // File was truncated/rotated
+                bytePosition = 0;
+            }
+        }
+        catch { /* file may have been removed */ }
+    });
+    process.on("SIGINT", () => {
+        watcher.close();
+        process.exit(0);
+    });
+    await new Promise(() => { }); // never resolves
+}

package/dist/cli/cmd-models.js

@@ -0,0 +1,125 @@
+import chalk from "chalk";
+import { readConfig, writeConfig } from "../config/manager.js";
+import { PROXY_PORT } from "../config/paths.js";
+import { buildModelRoutingUpdate } from "../protocol/model-routing-config.js";
+import { resolveStatusTarget } from "./cmd-status.js";
+export function groupModelsByProvider(models) {
+    const anthropic = new Set();
+    const openai = new Set();
+    const aliases = new Set();
+    for (const model of models) {
+        if (model.id.startsWith("anthropic/"))
+            anthropic.add(model.id);
+        else if (model.id.startsWith("openai/"))
+            openai.add(model.id);
+        else
+            aliases.add(model.id);
+    }
+    return {
+        anthropic: [...anthropic].sort(),
+        openai: [...openai].sort(),
+        aliases: [...aliases].sort(),
+    };
+}
+export function buildModelSetPayload(opts) {
+    return {
+        claudeModel: opts.claudeModel?.replace(/^anthropic\//, ""),
+        openAIModel: opts.openAIModel?.replace(/^openai\//, ""),
+    };
+}
+export function registerModels(program) {
+    const models = program
+        .command("models")
+        .description("List discovered provider models and update router model defaults");
+    models
+        .command("list")
+        .description("List models discovered from provider APIs through the running proxy")
+        .option("--port <port>", "Proxy port to connect to", String(PROXY_PORT))
+        .option("--json", "Output raw model status JSON")
+        .action(async (opts) => {
+        const status = await fetchRouterModels(parseInt(opts.port, 10));
+        if (opts.json) {
+            console.log(JSON.stringify(status, null, 2));
+            return;
+        }
+        printModels(status);
+    });
+    models
+        .command("set")
+        .description("Update Claude/OpenAI default models used by router aliases")
+        .option("--port <port>", "Proxy port to connect to", String(PROXY_PORT))
+        .option("--claude-model <model>", "Claude/Anthropic model id, with or without anthropic/ prefix")
+        .option("--openai-model <model>", "OpenAI/Codex model id, with or without openai/ prefix")
+        .action(async (opts) => {
+        if (!opts.claudeModel && !opts.openaiModel) {
+            console.error(chalk.red("Provide at least one model: --claude-model or --openai-model"));
+            process.exit(1);
+        }
+        const payload = buildModelSetPayload({
+            claudeModel: opts.claudeModel,
+            openAIModel: opts.openaiModel,
+        });
+        try {
+            const updated = await patchRouterModels(parseInt(opts.port, 10), payload);
+            console.log(chalk.green("✓ Updated running router model defaults."));
+            printRouting(updated.routing ?? {});
+        }
+        catch (err) {
+            const cfg = readConfig();
+            const modelRouting = buildModelRoutingUpdate(cfg.modelRouting, payload);
+            writeConfig({ ...cfg, modelRouting });
+            console.log(chalk.yellow("⚠ Could not update the running router; saved config for next start."));
+            console.log(chalk.gray(`  ${err.message}`));
+            printRouting(modelRouting);
+        }
+    });
+}
+async function fetchRouterModels(port) {
+    const target = resolveStatusTarget(port);
+    const res = await fetch(`${target.baseUrl}/cc-router/models`, {
+        headers: target.headers,
+        signal: AbortSignal.timeout(5_000),
+    });
+    if (!res.ok)
+        throw new Error(`Proxy returned HTTP ${res.status}`);
+    return await res.json();
+}
+async function patchRouterModels(port, payload) {
+    const target = resolveStatusTarget(port);
+    const res = await fetch(`${target.baseUrl}/cc-router/models`, {
+        method: "PATCH",
+        headers: {
+            "content-type": "application/json",
+            ...target.headers,
+        },
+        body: JSON.stringify(payload),
+        signal: AbortSignal.timeout(5_000),
+    });
+    if (!res.ok)
+        throw new Error(`Proxy returned HTTP ${res.status}`);
+    return await res.json();
+}
+function printModels(status) {
+    const groups = groupModelsByProvider(status.models ?? []);
+    console.log(chalk.bold("\n  Models\n"));
+    printRouting(status.routing ?? {});
+    printGroup("Claude / Anthropic", groups.anthropic);
+    printGroup("OpenAI / Codex", groups.openai);
+    printGroup("Aliases", groups.aliases);
+    console.log(chalk.gray("\n  Change defaults with:"));
+    console.log(chalk.cyan("  cc-router models set --claude-model anthropic/<id> --openai-model openai/<id>\n"));
+}
+function printGroup(label, ids) {
+    console.log(chalk.bold(`\n  ${label}`));
+    if (ids.length === 0) {
+        console.log(chalk.gray("    (none discovered)"));
+        return;
+    }
+    for (const id of ids)
+        console.log(`    ${id}`);
+}
+function printRouting(routing) {
+    console.log(chalk.gray("  Current routing:"));
+    console.log(`    Claude default: ${chalk.cyan(routing.anthropicDefaultModel ?? "(not set)")}`);
+    console.log(`    OpenAI default: ${chalk.cyan(routing.openAIDefaultModel ?? "(not set)")}`);
+}