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 模型。
//! OpenCode、OpenClaw、Hermes、pi、Atomcode:菜单、快捷设置与连接测试。
//!
//! 交互和输出与 Claude Code 保持一致:Base URL / API Key / 模型 / 保存方式,保存后显示配置结果、
//! 切换与 CC Switch 状态,并自动测试默认模型的连接。

use opentoken_core::models::format_base_url_for_display;
use opentoken_core::services::coexist::{self as service, CoexistPatch, CoexistSaveReport, CoexistTool};
use opentoken_core::services::{ModelSync, SyncOptions};
use opentoken_core::test_connection::test_openai;
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>,
    /// 菜单里拉取到的模型列表;None 时保存前重新拉取。
    models: Option<Vec<String>>,
}

fn effective(ctx: &Context, tool: CoexistTool, p: &Pending) -> (String, String, String) {
    let disk = tool.current(ctx);
    let url = tool.effective_base_url(&disk);
    (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, tool: CoexistTool, sync: SyncOptions) -> AnyResult<()> {
    let mut ctx = ctx.clone();
    let mut p = Pending::default();
    loop {
        ui::paint();
        let (key, url, model) = effective(&ctx, tool, &p);
        let items = vec![
            format!("1. 配置 Base URL{}", ui::gray_paren(&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(&format!("{} 配置:", tool.display_name()), &items, 0)? {
            0 => {
                ui::paint();
                let next = ui::input_url("请输入 Base URL:", &url)?;
                ui::ok_line(&format!("Base URL 已更新:{next}"));
                p.base_url = Some(next);
                p.models = None;
            }
            1 => {
                ui::paint();
                if let Some(k) = ui::read_api_key("请输入 API Key:")? {
                    p.api_key = Some(k);
                    p.models = None;
                }
            }
            2 => {
                ui::paint();
                let (m, models) = choose_model(&url, &key, &model).await?;
                p.model = Some(m);
                p.models = models;
            }
            3 => ui::choose_config_mode(&mut ctx)?,
            4 => {
                let patch = CoexistPatch { api_key: p.api_key.clone(), base_url: p.base_url.clone(), model: p.model.clone() };
                let report = service::save(&ctx, tool, &patch, p.models.clone(), sync).await?;
                println!();
                ui::title(&format!("{} 配置已更新:", tool.display_name()));
                print_report(&report, p.api_key.as_deref());
                println!();
                return test(&ctx, tool, None).await;
            }
            _ => return Ok(()),
        }
    }
}

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

fn print_report(r: &CoexistSaveReport, key: Option<&str>) {
    if let Some(k) = key {
        ui::field("API Key ", &mask_api_key(k));
    }
    if !r.config.base_url.is_empty() {
        ui::field("Base URL", &format_base_url_for_display(&r.config.base_url));
    }
    ui::field("默认模型", &r.tool.model_label(&r.config.model));
    match &r.models {
        ModelSync::Failed { error } => ui::warn(&format!("模型列表 : 无法拉取({error}),已保留现有模型列表")),
        // Atomcode 每个供应商只有一个模型,没有模型列表。
        ModelSync::Written { .. } if r.tool == CoexistTool::Atomcode => {}
        ModelSync::Written { count, .. } => ui::field("模型列表", &format!("已写入 {count} 个模型")),
        ModelSync::Skipped => {}
    }
    if !r.synced.is_empty() {
        ui::field("同步供应商", &r.synced.join("、"));
    }
    if r.switched {
        ui::field("当前配置", "已切换到 OpenToken");
    }
    if let Some(result) = &r.ccswitch {
        super::print_ccswitch(result, "", true);
    }
}

pub async fn quick_set(
    ctx: &Context,
    tool: CoexistTool,
    key: Option<&str>,
    url: Option<&str>,
    model: Option<&str>,
    sync: SyncOptions,
) -> AnyResult<()> {
    let patch = CoexistPatch { api_key: key.map(String::from), base_url: url.map(String::from), model: model.map(String::from) };
    if patch.is_empty() {
        return Ok(());
    }
    let report = service::save(ctx, tool, &patch, None, sync).await?;
    println!();
    ui::title(&format!("{} 配置已更新:", tool.display_name()));
    print_report(&report, key);
    println!();
    Ok(())
}

/// 只测默认模型(或 -m 指定的模型)。
pub async fn test(ctx: &Context, tool: CoexistTool, model: Option<&str>) -> AnyResult<()> {
    let config = tool.current(ctx);
    let model = model.map(String::from).unwrap_or(config.model.clone());
    if !super::require_configured(&config.api_key, &model, "请先配置模型") {
        return Ok(());
    }
    let base_url = tool.effective_base_url(&config);
    let label = tool.model_label(&model);
    println!();
    ui::title(&format!("正在测试 {} 连接...", tool.display_name()));
    ui::gray(&format!("  Base URL : {base_url}"));
    ui::gray(&format!("  API Key  : {}", mask_api_key(&config.api_key)));
    println!();
    let result = ui::with_spinner(&label, test_openai(&base_url, &config.api_key, &model)).await;
    ui::print_test(&label, &result);
    println!();
    Ok(())
}