src/main.rs

use clap::Parser;
use std::sync::Arc;
use tokio::net::TcpListener;
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};

mod adapter;
mod error;
mod handlers;
mod server;
mod token_counter;
mod types;

use token_counter::TokenCounter;

#[derive(Parser, Debug)]
#[command(name = "claude-code-adapter")]
#[command(about = "Proxy that converts Anthropic API to OpenRouter API")]
struct Args {
    /// Host to bind to
    #[arg(long, default_value = "0.0.0.0")]
    host: String,

    /// Port to listen on
    #[arg(short, long, default_value = "7860")]
    port: u16,

    /// OpenRouter API key (optional, can be passed via x-api-key header)
    #[arg(long, env = "OPENROUTER_API_KEY", default_value = "")]
    openrouter_api_key: String,

    /// Backend base URL
    #[arg(long, default_value = "https://router.huggingface.co")]
    openrouter_base_url: String,
}

#[derive(Clone)]
pub struct AppState {
    pub http_client: reqwest::Client,
    pub token_counter: Arc<TokenCounter>,
    pub openrouter_api_key: String,
    pub openrouter_base_url: String,
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // Initialize tracing
    tracing_subscriber::registry()
        .with(
            tracing_subscriber::EnvFilter::try_from_default_env()
                .unwrap_or_else(|_| "claude_code_adapter=info,tower_http=info".into()),
        )
        .with(tracing_subscriber::fmt::layer())
        .init();

    // Parse CLI arguments
    let args = Args::parse();

    // Create HTTP client
    let http_client = reqwest::Client::builder()
        .timeout(std::time::Duration::from_secs(300))
        .build()?;

    // Create app state
    let state = AppState {
        http_client,
        token_counter: Arc::new(TokenCounter::new()),
        openrouter_api_key: args.openrouter_api_key,
        openrouter_base_url: args.openrouter_base_url,
    };

    // Create router
    let app = server::create_router(state);

    // Bind and serve
    let addr = format!("{}:{}", args.host, args.port);
    let listener = TcpListener::bind(&addr).await?;
    tracing::info!("Listening on {}", addr);

    axum::serve(listener, app).await?;

    Ok(())
}