opentoken-cli 0.0.1

Configure Claude Code, Claude Desktop, Codex, OpenCode, OpenClaw, Hermes, pi and Atomcode for the OpenToken gateway in one command. OpenToken 一键接入 AI 模型。
//! Claude Code:~/.claude-opentoken/settings.json(--overwrite 写 ~/.claude/settings.json)。

use opentoken_core::clients::claude::{self as client, ClaudePatch, ModelPicks};
use opentoken_core::fetch_models::{fetch_models_for_base_url, AuthScheme, FetchOptions};
use opentoken_core::json::truthy_string;
use opentoken_core::models::{format_base_url_for_display, DEFAULT_BASE_URL};
use opentoken_core::services::{claude as service, ModelSync, SyncOptions};
use opentoken_core::test_connection::test_anthropic;
use opentoken_core::{mask_api_key, Context};

use crate::ui::{self, AnyResult};

#[derive(Default)]
struct Pending {
    api_key: Option<String>,
    base_url: Option<String>,
    model: Option<String>,
}

/// (api_key, base_url, model):待保存的值优先,未配置 URL 时使用默认节点。
fn effective(ctx: &Context, p: &Pending) -> AnyResult<(String, String, String)> {
    let disk = client::get_current_config(ctx)?;
    let url = if disk.base_url.is_empty() { DEFAULT_BASE_URL.to_string() } else { disk.base_url };
    Ok((
        p.api_key.clone().unwrap_or(disk.api_key),
        p.base_url.clone().unwrap_or(url),
        p.model.clone().unwrap_or(disk.model),
    ))
}

pub async fn run(ctx: &Context, sync: SyncOptions) -> AnyResult<()> {
    let mut ctx = ctx.clone();
    let mut p = Pending::default();
    loop {
        ui::paint();
        let (key, url, model) = effective(&ctx, &p)?;
        let items = vec![
            format!("1. 配置 Base URL{}", ui::gray_paren(ui::or_unset(&url))),
            format!("2. 配置 API Key{}", ui::gray_paren(&ui::masked_or_unset(&key))),
            format!("3. 配置模型{}", ui::gray_paren(ui::or_unset(&model))),
            ui::mode_item(&ctx),
            "4. 应用配置并保存".into(),
            "← 返回上级菜单".into(),
        ];
        match ui::select("请选择操作:", &items, 0)? {
            0 => {
                ui::paint();
                p.base_url = Some(ui::choose_base_url(&url)?);
            }
            1 => {
                ui::paint();
                if let Some(k) = ui::read_api_key("请输入 API Key:")? {
                    p.api_key = Some(k);
                }
            }
            2 => {
                ui::paint();
                p.model = Some(choose_model(&url, &key, &model).await?);
            }
            3 => ui::choose_config_mode(&mut ctx)?,
            4 => {
                let patch = ClaudePatch { api_key: p.api_key.clone(), base_url: Some(url), model: p.model.clone() };
                let report = service::save(&ctx, &patch, p.model.is_some(), sync).await?;
                println!();
                ui::ok_line("配置已成功写入");
                print_report(&report);
                println!();
                return super::Tool::Claude.test_after_save(&ctx).await;
            }
            _ => return Ok(()),
        }
    }
}

async fn choose_model(url: &str, key: &str, current: &str) -> AnyResult<String> {
    let fetched = fetch_models_for_base_url(url, key, &FetchOptions::anthropic()).await;
    if fetched.has_models() {
        if let (Some(model), _) = ui::pick_from_list(&fetched.models, current, None, "请选择模型:")? {
            return Ok(model);
        }
        return ui::input_model("请输入模型 ID:", current);
    }
    ui::yellow(&format!("  无法拉取模型列表:{}", fetched.error_text()));
    ui::gray("  请检查 Base URL、网络或 API Key 后重试,或直接输入模型 ID。");
    ui::input_model("请输入模型 ID:", current)
}

fn print_report(r: &service::ClaudeSaveReport) {
    if !r.config.base_url.is_empty() {
        ui::field("Base URL", &format_base_url_for_display(&r.config.base_url));
    }
    ui::field("默认模型", if r.config.model.is_empty() { "未指定" } else { &r.config.model });
    match &r.models {
        ModelSync::Failed { error } => ui::warn(&format!("模型列表 : 无法拉取({error}),已跳过")),
        ModelSync::Written { count, .. } => ui::field("模型列表", &format!("已写入 {count} 个模型到 /model 选择器")),
        ModelSync::Skipped => {}
    }
    if let Some(result) = &r.ccswitch {
        super::print_ccswitch(result, "", false);
    }
    super::print_switch(r.switch.as_ref(), "");
}

pub async fn quick_set(
    ctx: &Context,
    key: Option<&str>,
    url: Option<&str>,
    model: Option<&str>,
    sync: SyncOptions,
) -> AnyResult<()> {
    let Some(patch) = service::quick_patch(ctx, key, url, model)? else { return Ok(()) };
    let report = service::save(ctx, &patch, model.is_some(), sync).await?;
    println!();
    ui::title("Claude Code 配置已更新:");
    if let Some(k) = key {
        ui::field("API Key ", &mask_api_key(k));
    }
    print_report(&report);
    println!();
    Ok(())
}

pub fn apply_preset(ctx: &Context, preset: &str) -> AnyResult<()> {
    println!();
    match preset.trim().to_lowercase().as_str() {
        "beta-disable" => {
            client::set_beta_disabled(ctx, true)?;
            ui::ok_line("已写入 CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS=1");
        }
        "beta-enable" => {
            client::set_beta_disabled(ctx, false)?;
            ui::ok_line("已移除 CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS");
        }
        _ => {
            ui::error(&format!("未知预设:{preset}"));
            ui::gray("  可用:beta-disable、beta-enable");
        }
    }
    println!();
    Ok(())
}

pub async fn test(ctx: &Context, model: Option<&str>) -> AnyResult<()> {
    let config = client::get_current_config(ctx)?;
    if config.api_key.is_empty() {
        ui::error("请先配置 API Key");
        return Ok(());
    }
    if config.base_url.is_empty() {
        ui::error("请先配置 Base URL");
        return Ok(());
    }
    println!();
    ui::title("正在测试 Claude Code 连接...");
    ui::gray(&format!("  Base URL : {}", config.base_url));
    ui::gray(&format!("  API Key  : {}", mask_api_key(&config.api_key)));
    println!();

    let run_one = |id: String| {
        let (url, key) = (config.base_url.clone(), config.api_key.clone());
        async move { test_anthropic(&url, &key, &id, AuthScheme::XApiKey).await }
    };

    if let Some(m) = model {
        let result = ui::with_spinner(m, run_one(m.to_string())).await;
        ui::print_test(m, &result);
        println!();
        return Ok(());
    }

    let settings = client::read_settings(ctx)?;
    let env = settings.get("env").and_then(|e| e.as_object());
    let env_model = |k: &str| env.and_then(|e| truthy_string(e.get(k)));
    let fb = ModelPicks::fallback();
    let mut entries: Vec<(String, String)> = [
        ("Haiku", "ANTHROPIC_DEFAULT_HAIKU_MODEL", fb.haiku),
        ("Sonnet", "ANTHROPIC_DEFAULT_SONNET_MODEL", fb.sonnet),
        ("Opus", "ANTHROPIC_DEFAULT_OPUS_MODEL", fb.opus),
        ("Fable", "ANTHROPIC_DEFAULT_FABLE_MODEL", fb.fable),
    ]
    .into_iter()
    .map(|(label, key, fallback)| (label.to_string(), env_model(key).or(fallback).unwrap_or_default()))
    .collect();
    if !config.model.is_empty() && !entries.iter().any(|(_, id)| *id == config.model) {
        entries.push(("主模型".into(), config.model.clone()));
    }
    let mut seen = std::collections::HashSet::new();
    entries.retain(|(_, id)| seen.insert(id.clone()));

    let mut ok = 0;
    for (label, id) in &entries {
        let text = format!("{label} ({id})");
        let result = ui::with_spinner(&text, run_one(id.clone())).await;
        ok += usize::from(result.ok);
        ui::print_test(&text, &result);
    }
    println!();
    ui::gray(&format!("  {ok}/{} 连接成功", entries.len()));
    println!();
    Ok(())
}