opentoken-cli 0.0.2

Configure Claude Code, Claude Desktop, Codex, OpenCode, OpenClaw, Hermes, pi and Atomcode for the OpenToken gateway in one command. OpenToken 一键接入 AI 模型。
//! 各客户端的交互菜单、快捷设置和连接测试;业务规则都在 opentoken-core。

pub mod claude;
pub mod codex;
pub mod coexist;
pub mod desktop;
pub mod gemini;


use console::style;
use opentoken_core::ccswitch::{SyncResult, SyncStatus};
use opentoken_core::models::DEFAULT_BASE_URL;
use opentoken_core::services::coexist::CoexistTool;
use opentoken_core::services::{self, SwitchOutcome, SyncOptions};
use opentoken_core::{mask_api_key, Context};

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

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Tool {
    Claude,
    Desktop,
    Atomcode,
    Openclaw,
    Hermes,
    Opencode,
    Codex,
    Pi,
    Gemini,
}

impl Tool {
    pub fn parse(name: &str) -> Option<Tool> {
        Some(match name {
            "cc" | "claude" => Tool::Claude,
            "claude_desktop" | "cdt" => Tool::Desktop,
            "atomcode" | "ac" => Tool::Atomcode,
            "openclaw" | "oc" => Tool::Openclaw,
            "hermes" | "hm" => Tool::Hermes,
            "opencode" | "od" => Tool::Opencode,
            "codex" | "cx" => Tool::Codex,
            "pi" => Tool::Pi,
            "gemini" | "gm" => Tool::Gemini,
            _ => return None,
        })
    }

    fn coexist(self) -> Option<CoexistTool> {
        Some(match self {
            Tool::Opencode => CoexistTool::Opencode,
            Tool::Openclaw => CoexistTool::Openclaw,
            Tool::Hermes => CoexistTool::Hermes,
            Tool::Pi => CoexistTool::Pi,
            Tool::Atomcode => CoexistTool::Atomcode,
            _ => return None,
        })
    }

    pub fn has_quick_args(self, args: &Args) -> bool {
        args.key.is_some() || args.model.is_some() || args.url.is_some()
    }

    pub async fn quick_set(self, ctx: &Context, args: &Args, sync: SyncOptions) -> AnyResult<()> {
        let (k, u, m) = (args.key.as_deref(), args.url.as_deref(), args.model.as_deref());
        match self {
            Tool::Claude => claude::quick_set(ctx, k, u, m, sync).await,
            Tool::Desktop => desktop::quick_set(ctx, k, u, m, sync).await,
            Tool::Codex => codex::quick_set(ctx, k, u, m, sync).await,
            Tool::Gemini => gemini::quick_set(ctx, k, u, m, sync).await,
            other => coexist::quick_set(ctx, other.coexist().expect("coexist tool"), k, u, m, sync).await,
        }
    }

    pub async fn run(self, ctx: &Context, sync: SyncOptions) -> AnyResult<()> {
        match self {
            Tool::Claude => claude::run(ctx, sync).await,
            Tool::Desktop => desktop::run(ctx, sync).await,
            Tool::Codex => codex::run(ctx, sync).await,
            Tool::Gemini => gemini::run(ctx, sync).await,
            other => coexist::run(ctx, other.coexist().expect("coexist tool"), sync).await,
        }
    }

    pub async fn test(self, ctx: &Context, model: Option<&str>) -> AnyResult<()> {
        match self {
            Tool::Claude => claude::test(ctx, model).await,
            Tool::Desktop => desktop::test(ctx, model).await,
            Tool::Codex => codex::test(ctx, model, true).await,
            Tool::Gemini => gemini::test(ctx, model).await,
            other => coexist::test(ctx, other.coexist().expect("coexist tool"), model).await,
        }
    }
}

impl Tool {
    /// 保存后自动执行一次连接测试,和配置结果一起输出。
    pub async fn test_after_save(self, ctx: &Context) -> AnyResult<()> {
        match self {
            // 刚保存的地址无需再次确认。
            Tool::Codex => codex::test(ctx, None, false).await,
            _ => self.test(ctx, None).await,
        }
    }
}

pub async fn main_menu(ctx: &Context, sync: SyncOptions) -> AnyResult<()> {
    const ITEMS: &[(&str, Option<Tool>)] = &[
        ("1. 配置 Claude Code", Some(Tool::Claude)),
        ("2. 配置 Claude Desktop", Some(Tool::Desktop)),
        ("3. 配置 Atomcode", Some(Tool::Atomcode)),
        ("4. 配置 OpenClaw", Some(Tool::Openclaw)),
        ("5. 配置 Hermes", Some(Tool::Hermes)),
        ("6. 配置 OpenCode", Some(Tool::Opencode)),
        ("7. 配置 Codex", Some(Tool::Codex)),
        ("8. 配置 pi", Some(Tool::Pi)),
        ("9. 配置 Gemini CLI", Some(Tool::Gemini)),
        ("10. 退出", None),
    ];
    let labels: Vec<String> = ITEMS.iter().map(|(l, _)| l.to_string()).collect();
    loop {
        ui::paint();
        match ITEMS[ui::select("请选择:", &labels, 0)?].1 {
            // 每次进入子菜单都从命令行指定的保存方式开始。
            Some(tool) => tool.run(ctx, sync).await?,
            None => {
                ui::clear_screen();
                println!("{}", style("再见!").cyan());
                return Ok(());
            }
        }
    }
}

pub async fn list_models(ctx: &Context, key: Option<&str>) -> AnyResult<()> {
    println!();
    println!("{}{}", style("可用模型列表").cyan().bold(), style(format!("({DEFAULT_BASE_URL})")).dim());
    println!();
    let (key, fetched) = match services::list_models(ctx, key).await {
        Ok(r) => r,
        Err(e) => {
            ui::error(&e.to_string());
            println!();
            return Ok(());
        }
    };
    if fetched.has_models() {
        for id in &fetched.models {
            println!("  {id}");
        }
        println!();
        ui::gray(&format!("共 {} 个模型", fetched.models.len()));
    } else {
        ui::error(&format!("获取失败:{}", fetched.error_text()));
    }
    ui::gray(&format!("API Key : {}", mask_api_key(&key)));
    println!();
    Ok(())
}

/// CC Switch 同步结果。label 为 \"\"、\"Desktop \"、\"Codex \";show_skipped 时提示除“未安装”外的跳过原因。
pub fn print_ccswitch(result: &SyncResult, label: &str, show_skipped: bool) {
    match result.status {
        SyncStatus::Updated | SyncStatus::Unchanged => {
            let action = if result.created.is_empty() { "已同步" } else { "已新增" };
            ui::field("CC Switch", &format!("{action} {label}供应商 {}", result.updated.join("、")));
        }
        SyncStatus::Error => ui::warn(&format!("CC Switch : {}", result.reason.as_deref().unwrap_or(""))),
        SyncStatus::Skipped if show_skipped && result.reason.as_deref() != Some("未检测到 CC Switch") => {
            ui::warn(&format!("CC Switch : {}", result.reason.as_deref().unwrap_or("")))
        }
        _ => {}
    }
    for warning in &result.warnings {
        ui::warn(&format!("CC Switch : {warning}"));
    }
}

pub fn print_switch(outcome: Option<&SwitchOutcome>, label: &str) {
    let Some(outcome) = outcome else { return };
    if outcome.switched && !outcome.via_ccswitch {
        ui::field("当前配置", &format!("已切换到 {}", outcome.provider_name.as_deref().unwrap_or("")));
    } else if outcome.switched {
        ui::field("CC Switch", &format!("已切换到 {label}供应商 {}", outcome.provider_name.as_deref().unwrap_or("")));
    } else {
        ui::warn(&format!("CC Switch : {}", outcome.reason.as_deref().unwrap_or("切换失败")));
    }
}

/// 检查 Key 和模型是否已配置。
pub fn require_configured(api_key: &str, model: &str, model_hint: &str) -> bool {
    if api_key.is_empty() {
        ui::error("请先配置 API Key");
        return false;
    }
    if model.is_empty() {
        ui::error(model_hint);
        return false;
    }
    true
}