pub mod claude;
pub mod codex;
pub mod coexist;
pub mod desktop;
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,
}
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,
_ => 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,
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,
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,
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. 退出", 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(())
}
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("切换失败")));
}
}
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
}