use crate::settings::{get_settings, update_settings};
use std::sync::OnceLock;
use std::sync::RwLock;
#[cfg(test)]
use std::cell::RefCell;
/// Supported languages
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Language {
English,
Chinese,
}
impl Language {
pub fn code(&self) -> &'static str {
match self {
Language::English => "en",
Language::Chinese => "zh",
}
}
pub fn display_name(&self) -> &'static str {
match self {
Language::English => "English",
Language::Chinese => "中文",
}
}
pub fn from_code(code: &str) -> Self {
match code.to_lowercase().as_str() {
"zh" | "zh-cn" | "zh-tw" | "chinese" => Language::Chinese,
_ => Language::English,
}
}
}
impl std::fmt::Display for Language {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{}", self.display_name())
}
}
/// Global language state
fn language_store() -> &'static RwLock<Language> {
static STORE: OnceLock<RwLock<Language>> = OnceLock::new();
STORE.get_or_init(|| {
let lang = if cfg!(test) {
// Keep unit tests deterministic and avoid reading real user settings.
Language::English
} else {
let settings = get_settings();
settings
.language
.as_deref()
.map(Language::from_code)
.unwrap_or(Language::English)
};
RwLock::new(lang)
})
}
#[cfg(test)]
thread_local! {
static TEST_LANGUAGE_OVERRIDE: RefCell<Option<Language>> = const { RefCell::new(None) };
}
#[cfg(test)]
pub(crate) struct TestLanguageGuard(Option<Language>);
#[cfg(test)]
impl Drop for TestLanguageGuard {
fn drop(&mut self) {
TEST_LANGUAGE_OVERRIDE.with(|slot| {
*slot.borrow_mut() = self.0;
});
}
}
#[cfg(test)]
pub(crate) fn use_test_language(lang: Language) -> TestLanguageGuard {
let previous = TEST_LANGUAGE_OVERRIDE.with(|slot| slot.replace(Some(lang)));
TestLanguageGuard(previous)
}
/// Get current language
pub fn current_language() -> Language {
#[cfg(test)]
if let Some(lang) = TEST_LANGUAGE_OVERRIDE.with(|slot| *slot.borrow()) {
return lang;
}
*language_store().read().expect("Failed to read language")
}
/// Set current language and persist
pub fn set_language(lang: Language) -> Result<(), crate::error::AppError> {
// Update runtime state
{
let mut guard = language_store().write().expect("Failed to write language");
*guard = lang;
}
// Persist to settings
let mut settings = get_settings();
settings.language = Some(lang.code().to_string());
update_settings(settings)
}
/// Check if current language is Chinese
pub fn is_chinese() -> bool {
current_language() == Language::Chinese
}
// ============================================================================
// Localized Text Macros and Functions
// ============================================================================
/// Get localized text based on current language
#[macro_export]
macro_rules! t {
($en:expr, $zh:expr) => {
if $crate::cli::i18n::is_chinese() {
$zh
} else {
$en
}
};
}
// Re-export for convenience
pub use t;
// ============================================================================
// Common UI Texts
// ============================================================================
pub mod texts {
use super::is_chinese;
// ============================================
// ENTITY TYPE CONSTANTS (实体类型常量)
// ============================================
pub fn entity_provider() -> &'static str {
if is_chinese() {
"供应商"
} else {
"provider"
}
}
pub fn entity_server() -> &'static str {
if is_chinese() {
"服务器"
} else {
"server"
}
}
pub fn entity_prompt() -> &'static str {
if is_chinese() {
"提示词"
} else {
"prompt"
}
}
// ============================================
// GENERIC ENTITY OPERATIONS (通用实体操作)
// ============================================
pub fn entity_added_success(entity_type: &str, name: &str) -> String {
if is_chinese() {
format!("✓ 成功添加{} '{}'", entity_type, name)
} else {
format!("✓ Successfully added {} '{}'", entity_type, name)
}
}
pub fn entity_updated_success(entity_type: &str, name: &str) -> String {
if is_chinese() {
format!("✓ 成功更新{} '{}'", entity_type, name)
} else {
format!("✓ Successfully updated {} '{}'", entity_type, name)
}
}
pub fn entity_deleted_success(entity_type: &str, name: &str) -> String {
if is_chinese() {
format!("✓ 成功删除{} '{}'", entity_type, name)
} else {
format!("✓ Successfully deleted {} '{}'", entity_type, name)
}
}
pub fn entity_not_found(entity_type: &str, id: &str) -> String {
if is_chinese() {
format!("{}不存在: {}", entity_type, id)
} else {
format!("{} not found: {}", entity_type, id)
}
}
pub fn confirm_create_entity(entity_type: &str) -> String {
if is_chinese() {
format!("\n确认创建此{}？", entity_type)
} else {
format!("\nConfirm create this {}?", entity_type)
}
}
pub fn confirm_update_entity(entity_type: &str) -> String {
if is_chinese() {
format!("\n确认更新此{}？", entity_type)
} else {
format!("\nConfirm update this {}?", entity_type)
}
}
pub fn confirm_delete_entity(entity_type: &str, name: &str) -> String {
if is_chinese() {
format!("\n确认删除{} '{}'？", entity_type, name)
} else {
format!("\nConfirm delete {} '{}'?", entity_type, name)
}
}
pub fn select_to_delete_entity(entity_type: &str) -> String {
if is_chinese() {
format!("选择要删除的{}：", entity_type)
} else {
format!("Select {} to delete:", entity_type)
}
}
pub fn no_entities_to_delete(entity_type: &str) -> String {
if is_chinese() {
format!("没有可删除的{}", entity_type)
} else {
format!("No {} available for deletion", entity_type)
}
}
// ============================================
// COMMON UI ELEMENTS (通用界面元素)
// ============================================
// Welcome & Headers
pub fn welcome_title() -> &'static str {
if is_chinese() {
" 🎯 CC-Switch 交互模式"
} else {
" 🎯 CC-Switch Interactive Mode"
}
}
pub fn application() -> &'static str {
if is_chinese() {
"应用程序"
} else {
"Application"
}
}
pub fn goodbye() -> &'static str {
if is_chinese() {
"👋 再见！"
} else {
"👋 Goodbye!"
}
}
// Main Menu
pub fn main_menu_prompt(app: &str) -> String {
if is_chinese() {
format!("请选择操作 (当前: {})", app)
} else {
format!("What would you like to do? (Current: {})", app)
}
}
pub fn interactive_requires_tty() -> &'static str {
if is_chinese() {
"交互模式需要在 TTY 终端中运行（请不要通过管道/重定向调用）。"
} else {
"Interactive mode requires a TTY (do not run with pipes/redirection)."
}
}
pub fn interactive_legacy_tui_removed() -> &'static str {
if is_chinese() {
"旧版 legacy TUI 已移除，请直接使用当前默认的交互 TUI。"
} else {
"The legacy TUI has been removed. Please use the default interactive TUI instead."
}
}
// Ratatui TUI (new interactive UI)
pub fn tui_app_title() -> &'static str {
"cc-switch-tui"
}
pub fn tui_tabs_title() -> &'static str {
if is_chinese() {
"App"
} else {
"App"
}
}
pub fn tui_hint_app_switch() -> &'static str {
if is_chinese() {
"切换 App:"
} else {
"Switch App:"
}
}
pub fn tui_filter_icon() -> &'static str {
"🔎 "
}
pub fn tui_marker_active() -> &'static str {
"✓"
}
pub fn tui_marker_inactive() -> &'static str {
" "
}
pub fn tui_highlight_symbol() -> &'static str {
"➤ "
}
pub fn tui_toast_prefix_info() -> &'static str {
" ℹ "
}
pub fn tui_toast_prefix_success() -> &'static str {
" ✓ "
}
pub fn tui_toast_prefix_warning() -> &'static str {
" ! "
}
pub fn tui_toast_prefix_error() -> &'static str {
" ✗ "
}
pub fn tui_toast_invalid_json(details: &str) -> String {
if is_chinese() {
format!("JSON 无效：{details}")
} else {
format!("Invalid JSON: {details}")
}
}
pub fn tui_toast_json_must_be_object() -> &'static str {
if is_chinese() {
"JSON 必须是对象（例如：{\"env\":{...}}）"
} else {
"JSON must be an object (e.g. {\"env\":{...}})"
}
}
pub fn tui_error_invalid_config_structure(e: &str) -> String {
if is_chinese() {
format!("配置结构无效：{e}")
} else {
format!("Invalid config structure: {e}")
}
}
pub fn tui_rule(width: usize) -> String {
if is_chinese() {
"─".repeat(width)
} else {
"─".repeat(width)
}
}
pub fn tui_rule_heavy(width: usize) -> String {
if is_chinese() {
"═".repeat(width)
} else {
"═".repeat(width)
}
}
pub fn tui_icon_app() -> &'static str {
"📱"
}
pub fn tui_default_config_filename() -> &'static str {
"config.json"
}
pub fn tui_default_config_export_path() -> &'static str {
"./config-export.sql"
}
pub fn tui_default_common_snippet() -> &'static str {
"{}\n"
}
pub fn tui_default_common_snippet_for_app(app: &str) -> &'static str {
match app {
"codex" => "",
_ => "{}\n",
}
}
pub fn tui_latency_ms(ms: u128) -> String {
if is_chinese() {
format!("{ms} ms")
} else {
format!("{ms} ms")
}
}
pub fn tui_nav_title() -> &'static str {
if is_chinese() {
"菜单"
} else {
"Menu"
}
}
pub fn tui_filter_title() -> &'static str {
if is_chinese() {
"过滤"
} else {
"Filter"
}
}
pub fn tui_footer_global() -> &'static str {
if is_chinese() {
"[ ] 切换应用 ←→ 切换菜单/内容 ↑↓ 移动 Enter 详情 s 切换 / 过滤 Esc 返回 ? 帮助"
} else {
"[ ] switch app ←→ focus menu/content ↑↓ move Enter details s switch / filter Esc back ? help"
}
}
pub fn tui_footer_group_nav() -> &'static str {
if is_chinese() {
"导航"
} else {
"NAV"
}
}
pub fn tui_footer_group_actions() -> &'static str {
if is_chinese() {
"功能"
} else {
"ACT"
}
}
pub fn tui_footer_nav_keys() -> &'static str {
if is_chinese() {
"←→ 菜单/内容 ↑↓ 移动"
} else {
"←→ menu/content ↑↓ move"
}
}
pub fn tui_footer_action_keys() -> &'static str {
if is_chinese() {
"[ ] 切换应用 Enter 详情 s 切换 / 过滤 Esc 返回 ? 帮助"
} else {
"[ ] switch app Enter details s switch / filter Esc back ? help"
}
}
pub fn tui_footer_action_keys_main() -> &'static str {
if is_chinese() {
"[ ] 切换应用 / 过滤 Esc 返回 ? 帮助"
} else {
"[ ] switch app / filter Esc back ? help"
}
}
pub fn tui_footer_action_keys_providers() -> &'static str {
if is_chinese() {
"[ ] 切换应用 Enter 详情 s 切换 a 添加 e 编辑 d 删除 t 测速 c 健康检查 / 过滤 Esc 返回 ? 帮助"
} else {
"[ ] switch app Enter details s switch a add e edit d delete t speedtest c stream check / filter Esc back ? help"
}
}
pub fn tui_footer_action_keys_provider_detail() -> &'static str {
if is_chinese() {
"[ ] 切换应用 s 切换 e 编辑 t 测速 c 健康检查 / 过滤 Esc 返回 ? 帮助"
} else {
"[ ] switch app s switch e edit t speedtest c stream check / filter Esc back ? help"
}
}
pub fn tui_footer_action_keys_mcp() -> &'static str {
if is_chinese() {
"[ ] 切换应用 x 启用/禁用 m 应用 a 添加 e 编辑 i 导入 d 删除 / 过滤 Esc 返回 ? 帮助"
} else {
"[ ] switch app x toggle m apps a add e edit i import d delete / filter Esc back ? help"
}
}
pub fn tui_footer_action_keys_prompts() -> &'static str {
if is_chinese() {
"[ ] 切换应用 c 新建 r 刷新 Enter 查看 a 激活 x 取消激活 n 重命名 e 编辑 d 删除 / 过滤 Esc 返回 ? 帮助"
} else {
"[ ] switch app c create r refresh Enter view a activate x deactivate n rename e edit d delete / filter Esc back ? help"
}
}
pub fn tui_footer_action_keys_config() -> &'static str {
if is_chinese() {
"[ ] 切换应用 Enter 打开 e 编辑片段 / 过滤 Esc 返回 ? 帮助"
} else {
"[ ] switch app Enter open e edit snippet / filter Esc back ? help"
}
}
pub fn tui_footer_action_keys_common_snippet_view() -> &'static str {
if is_chinese() {
"a 应用 c 清空 e 编辑 ↑↓ 滚动 Esc 返回"
} else {
"a apply c clear e edit ↑↓ scroll Esc back"
}
}
pub fn tui_footer_action_keys_settings() -> &'static str {
if is_chinese() {
"[ ] 切换应用 Enter 应用 / 过滤 Esc 返回 ? 帮助"
} else {
"[ ] switch app Enter apply / filter Esc back ? help"
}
}
pub fn tui_footer_action_keys_global() -> &'static str {
if is_chinese() {
"[ ] 切换应用 / 过滤 Esc 返回 ? 帮助"
} else {
"[ ] switch app / filter Esc back ? help"
}
}
pub fn tui_footer_filter_mode() -> &'static str {
if is_chinese() {
"输入关键字过滤，Enter 应用，Esc 清空并退出"
} else {
"Type to filter, Enter apply, Esc clear & exit"
}
}
pub fn tui_help_title() -> &'static str {
if is_chinese() {
"帮助"
} else {
"Help"
}
}
pub fn tui_help_text() -> &'static str {
if is_chinese() {
"[ ] 切换应用\n←→ 切换菜单/内容焦点\n↑↓ 移动\n/ 过滤\nEsc 返回\n? 显示/关闭帮助\n\n页面快捷键（在页面内容区顶部显示）：\n- 供应商：Enter 详情，s 切换/添加移除，a 添加，e 编辑，d 删除，t 测速，c 健康检查\n- 供应商详情：s 切换/添加移除，e 编辑，t 测速，c 健康检查\n- MCP：x 启用/禁用(当前应用)，m 选择应用，a 添加，e 编辑，i 导入已有，d 删除\n- 提示词：c 新建，r 刷新，Enter 查看，a 激活，x 取消激活(当前)，n 重命名，e 编辑，d 删除\n- 技能：Enter 详情，x 启用/禁用(当前应用)，m 选择应用，d 卸载，i 导入已有\n- 配置：Enter 打开/执行，e 编辑片段\n- 设置：Enter 应用"
} else {
"[ ] switch app\n←→ focus menu/content\n↑↓ move\n/ filter\nEsc back\n? toggle help\n\nPage keys (shown at the top of each page):\n- Providers: Enter details, s switch/add-remove, a add, e edit, d delete, t speedtest, c stream check\n- Provider Detail: s switch/add-remove, e edit, t speedtest, c stream check\n- MCP: x toggle current, m select apps, a add, e edit, i import existing, d delete\n- Prompts: c create, r refresh, Enter view, a activate, x deactivate active, n rename, e edit, d delete\n- Skills: Enter details, x toggle current, m select apps, d uninstall, i import existing\n- Config: Enter open/run, e edit snippet\n- Settings: Enter apply"
}
}
pub fn tui_confirm_title() -> &'static str {
if is_chinese() {
"确认"
} else {
"Confirm"
}
}
pub fn tui_confirm_exit_title() -> &'static str {
if is_chinese() {
"退出"
} else {
"Exit"
}
}
pub fn tui_confirm_exit_message() -> &'static str {
if is_chinese() {
"确定退出 cc-switch？"
} else {
"Exit cc-switch?"
}
}
pub fn tui_confirm_yes_hint() -> &'static str {
if is_chinese() {
"y/Enter = 是"
} else {
"y/Enter = Yes"
}
}
pub fn tui_confirm_no_hint() -> &'static str {
if is_chinese() {
"n/Esc = 否"
} else {
"n/Esc = No"
}
}
pub fn tui_input_title() -> &'static str {
if is_chinese() {
"输入"
} else {
"Input"
}
}
pub fn tui_editor_text_field_title() -> &'static str {
if is_chinese() {
"文本"
} else {
"Text"
}
}
pub fn tui_editor_json_field_title() -> &'static str {
"JSON"
}
pub fn tui_editor_hint_view() -> &'static str {
if is_chinese() {
"Enter 编辑 ↑↓ 滚动 Ctrl+S 保存 Esc 返回"
} else {
"Enter edit ↑↓ scroll Ctrl+S save Esc back"
}
}
pub fn tui_editor_hint_edit() -> &'static str {
if is_chinese() {
"编辑中：Esc 退出编辑 Ctrl+S 保存"
} else {
"Editing: Esc stop editing Ctrl+S save"
}
}
pub fn tui_editor_discard_title() -> &'static str {
if is_chinese() {
"放弃修改"
} else {
"Discard Changes"
}
}
pub fn tui_editor_discard_message() -> &'static str {
if is_chinese() {
"有未保存的修改，确定放弃？"
} else {
"You have unsaved changes. Discard them?"
}
}
pub fn tui_editor_save_before_close_title() -> &'static str {
if is_chinese() {
"当前未保存"
} else {
"Unsaved Changes"
}
}
pub fn tui_editor_save_before_close_message() -> &'static str {
if is_chinese() {
"当前有未保存的修改。"
} else {
"You have unsaved changes."
}
}
pub fn tui_speedtest_title() -> &'static str {
if is_chinese() {
"测速"
} else {
"Speedtest"
}
}
pub fn tui_stream_check_title() -> &'static str {
if is_chinese() {
"健康检查"
} else {
"Stream Check"
}
}
pub fn tui_main_hint() -> &'static str {
if is_chinese() {
"使用左侧菜单（↑↓ + Enter）。←→ 在菜单与内容间切换焦点。"
} else {
"Use the left menu (↑↓ + Enter). ←→ switches focus between menu and content."
}
}
pub fn tui_header_proxy_status(enabled: bool) -> String {
if is_chinese() {
format!("代理: {}", if enabled { "开" } else { "关" })
} else {
format!("Proxy: {}", if enabled { "On" } else { "Off" })
}
}
pub fn tui_header_config_error() -> &'static str {
if is_chinese() {
"配置错误"
} else {
"Config Error"
}
}
pub fn tui_home_section_connection() -> &'static str {
if is_chinese() {
"连接信息"
} else {
"Connection Details"
}
}
pub fn tui_home_section_proxy() -> &'static str {
if is_chinese() {
"代理仪表盘"
} else {
"Proxy Dashboard"
}
}
pub fn tui_home_section_context() -> &'static str {
if is_chinese() {
"Session Context"
} else {
"Session Context"
}
}
pub fn tui_home_section_local_env_check() -> &'static str {
if is_chinese() {
"本地环境检查"
} else {
"Local environment check"
}
}
pub fn tui_home_section_webdav() -> &'static str {
if is_chinese() {
"WebDAV 同步"
} else {
"WebDAV Sync"
}
}
pub fn tui_label_webdav_status() -> &'static str {
if is_chinese() {
"状态"
} else {
"Status"
}
}
pub fn tui_label_webdav_last_sync() -> &'static str {
if is_chinese() {
"最近同步"
} else {
"Last sync"
}
}
pub fn tui_webdav_status_not_configured() -> &'static str {
if is_chinese() {
"未配置"
} else {
"Not configured"
}
}
pub fn tui_webdav_status_configured() -> &'static str {
if is_chinese() {
"已配置"
} else {
"Configured"
}
}
pub fn tui_webdav_status_never_synced() -> &'static str {
if is_chinese() {
"从未同步"
} else {
"Never synced"
}
}
pub fn tui_webdav_status_ok() -> &'static str {
if is_chinese() {
"正常"
} else {
"OK"
}
}
pub fn tui_webdav_status_error() -> &'static str {
if is_chinese() {
"失败"
} else {
"Error"
}
}
pub fn tui_webdav_status_error_with_detail(detail: &str) -> String {
if is_chinese() {
format!("失败（{detail}）")
} else {
format!("Error ({detail})")
}
}
pub fn tui_local_env_not_installed() -> &'static str {
if is_chinese() {
"未安装或不可执行"
} else {
"not installed or not executable"
}
}
pub fn tui_home_status_online() -> &'static str {
if is_chinese() {
"在线"
} else {
"Online"
}
}
pub fn tui_home_status_offline() -> &'static str {
if is_chinese() {
"离线"
} else {
"Offline"
}
}
pub fn tui_proxy_dashboard_status_running() -> &'static str {
if is_chinese() {
"已启用"
} else {
"ACTIVE"
}
}
pub fn tui_proxy_dashboard_status_stopped() -> &'static str {
if is_chinese() {
"本地"
} else {
"LOCAL"
}
}
pub fn tui_proxy_dashboard_status_local_only() -> &'static str {
if is_chinese() {
"仅本地"
} else {
"LOCAL ONLY"
}
}
pub fn tui_proxy_dashboard_status_unsupported() -> &'static str {
if is_chinese() {
"不支持"
} else {
"UNSUPPORTED"
}
}
pub fn tui_proxy_dashboard_manual_routing_copy(app: &str) -> String {
if is_chinese() {
format!("手动路由：{app} 的流量会通过 cc-switch。")
} else {
format!("Manual routing only: traffic goes through cc-switch for {app}.")
}
}
pub fn tui_proxy_dashboard_failover_copy() -> &'static str {
if is_chinese() {
"仅做手动路由，不会自动切换供应商。"
} else {
"automatic failover stays off; provider changes stay manual."
}
}
pub fn tui_proxy_dashboard_cta_start(app: &str) -> String {
if is_chinese() {
format!("按 P 启动托管代理，并让 {app} 走 cc-switch。")
} else {
format!("Press P to start the managed proxy and route {app} through cc-switch.")
}
}
pub fn tui_proxy_dashboard_cta_stop(app: &str) -> String {
if is_chinese() {
format!("按 P 恢复 {app} 的 live 配置，并停止托管代理。")
} else {
format!("Press P to restore {app} to its live config and stop the managed proxy.")
}
}
pub fn tui_proxy_loading_title_start() -> &'static str {
if is_chinese() {
"启动代理中"
} else {
"Starting proxy"
}
}
pub fn tui_proxy_loading_title_stop() -> &'static str {
if is_chinese() {
"停止代理中"
} else {
"Stopping proxy"
}
}
pub fn tui_proxy_dashboard_running_elsewhere() -> &'static str {
if is_chinese() {
"代理已在运行。请先停止当前路由，再从这里启动。"
} else {
"Proxy is already running. Stop the current route before starting it here."
}
}
pub fn tui_proxy_dashboard_current_app_on(app: &str) -> String {
if is_chinese() {
format!("{app} 已接入代理")
} else {
format!("{app} active")
}
}
pub fn tui_proxy_dashboard_current_app_off(app: &str) -> String {
if is_chinese() {
format!("{app} 本地直连")
} else {
format!("{app} local")
}
}
pub fn tui_proxy_dashboard_unsupported_app(app: &str) -> String {
if is_chinese() {
format!("{app} 仅本地")
} else {
format!("{app} local only")
}
}
pub fn tui_proxy_dashboard_shared_runtime_ready() -> &'static str {
if is_chinese() {
"共享 runtime 就绪"
} else {
"Shared runtime ready"
}
}
pub fn tui_proxy_dashboard_no_route_for_app(app: &str) -> String {
if is_chinese() {
format!("{app} 暂无路由")
} else {
format!("No route for {app} yet")
}
}
pub fn tui_proxy_dashboard_takeover_active() -> &'static str {
if is_chinese() {
"已接管"
} else {
"active"
}
}
pub fn tui_proxy_dashboard_takeover_inactive() -> &'static str {
if is_chinese() {
"未接管"
} else {
"inactive"
}
}
pub fn tui_proxy_dashboard_takeover_unsupported() -> &'static str {
if is_chinese() {
"不支持"
} else {
"not supported"
}
}
pub fn tui_proxy_dashboard_uptime_stopped() -> &'static str {
if is_chinese() {
"未运行"
} else {
"--"
}
}
pub fn tui_proxy_dashboard_requests_idle() -> &'static str {
if is_chinese() {
"暂无流量"
} else {
"No traffic yet"
}
}
pub fn tui_proxy_dashboard_tokens_idle() -> &'static str {
if is_chinese() {
"暂无 token 流量"
} else {
"No token traffic yet"
}
}
pub fn tui_proxy_dashboard_target_waiting() -> &'static str {
if is_chinese() {
"等待首个请求"
} else {
"Waiting for first request"
}
}
pub fn tui_proxy_dashboard_request_summary(total: u64, success_rate: f32) -> String {
if is_chinese() {
format!("{total} 总计 / {success_rate:.1}% 成功")
} else {
format!("{total} total / {success_rate:.1}% success")
}
}
pub fn tui_proxy_dashboard_token_summary(output: &str, input: &str) -> String {
if is_chinese() {
format!("{output} 下行 / {input} 上行")
} else {
format!("{output} out / {input} in")
}
}
pub fn tui_label_current_app_takeover() -> &'static str {
if is_chinese() {
"当前应用接管"
} else {
"Current app takeover"
}
}
pub fn tui_label_current_app_route() -> &'static str {
if is_chinese() {
"当前应用路由"
} else {
"Current app route"
}
}
pub fn tui_label_current() -> &'static str {
if is_chinese() {
"当前"
} else {
"Current"
}
}
pub fn tui_provider_none() -> &'static str {
if is_chinese() {
"无"
} else {
"None"
}
}
pub fn tui_label_latest_proxy_route() -> &'static str {
if is_chinese() {
"最近代理路由"
} else {
"Latest proxy route"
}
}
pub fn tui_label_shared_runtime() -> &'static str {
if is_chinese() {
"共享 runtime"
} else {
"Shared runtime"
}
}
pub fn tui_label_listen() -> &'static str {
if is_chinese() {
"监听"
} else {
"Listen"
}
}
pub fn tui_label_uptime() -> &'static str {
if is_chinese() {
"运行时长"
} else {
"Uptime"
}
}
pub fn tui_label_requests() -> &'static str {
if is_chinese() {
"请求"
} else {
"Requests"
}
}
pub fn tui_label_traffic() -> &'static str {
if is_chinese() {
"流量"
} else {
"Traffic"
}
}
pub fn tui_label_proxy_requests() -> &'static str {
if is_chinese() {
"代理总请求"
} else {
"Proxy requests"
}
}
pub fn tui_label_active_target() -> &'static str {
if is_chinese() {
"当前路由目标"
} else {
"Active target"
}
}
pub fn tui_label_last_error() -> &'static str {
if is_chinese() {
"最近错误"
} else {
"Last error"
}
}
pub fn tui_label_last_proxy_error() -> &'static str {
if is_chinese() {
"最近一次代理错误"
} else {
"Last proxy error"
}
}
pub fn tui_label_mcp_servers_active() -> &'static str {
if is_chinese() {
"已启用"
} else {
"Active"
}
}
pub fn tui_na() -> &'static str {
"N/A"
}
pub fn tui_loading() -> &'static str {
if is_chinese() {
"处理中…"
} else {
"Working…"
}
}
pub fn tui_header_quota() -> &'static str {
if is_chinese() {
"额度"
} else {
"Quota"
}
}
pub fn tui_label_quota() -> &'static str {
if is_chinese() {
"额度"
} else {
"Quota"
}
}
pub fn tui_quota_loading() -> &'static str {
if is_chinese() {
"查询中…"
} else {
"checking…"
}
}
pub fn tui_quota_not_available() -> &'static str {
if is_chinese() {
"不可用"
} else {
"not available"
}
}
pub fn tui_quota_parse_error() -> &'static str {
if is_chinese() {
"凭据解析失败"
} else {
"credential parse failed"
}
}
pub fn tui_quota_expired() -> &'static str {
if is_chinese() {
"登录过期"
} else {
"login expired"
}
}
pub fn tui_quota_query_failed() -> &'static str {
if is_chinese() {
"查询失败"
} else {
"query failed"
}
}
pub fn tui_quota_not_queried() -> &'static str {
if is_chinese() {
"未查询"
} else {
"not queried"
}
}
pub fn tui_quota_refresh_hint() -> &'static str {
if is_chinese() {
"按 r 刷新"
} else {
"press r to refresh"
}
}
pub fn tui_quota_ok() -> &'static str {
if is_chinese() {
"已获取"
} else {
"ok"
}
}
pub fn tui_quota_last_checked() -> &'static str {
if is_chinese() {
"更新于"
} else {
"checked"
}
}
pub fn tui_quota_resets_in(time: &str) -> String {
if is_chinese() {
format!("{time} 后重置")
} else {
format!("resets in {time}")
}
}
pub fn tui_quota_just_now() -> &'static str {
if is_chinese() {
"刚刚"
} else {
"just now"
}
}
pub fn tui_quota_minutes_ago(count: i64) -> String {
if is_chinese() {
format!("{count} 分钟前")
} else if count == 1 {
"1 minute ago".to_string()
} else {
format!("{count} minutes ago")
}
}
pub fn tui_quota_hours_ago(count: i64) -> String {
if is_chinese() {
format!("{count} 小时前")
} else if count == 1 {
"1 hour ago".to_string()
} else {
format!("{count} hours ago")
}
}
pub fn tui_quota_days_ago(count: i64) -> String {
if is_chinese() {
format!("{count} 天前")
} else if count == 1 {
"1 day ago".to_string()
} else {
format!("{count} days ago")
}
}
pub fn tui_quota_extra_usage() -> &'static str {
if is_chinese() {
"额外用量"
} else {
"Extra usage"
}
}
pub fn tui_quota_tier_five_hour() -> &'static str {
if is_chinese() {
"5小时"
} else {
"5h"
}
}
pub fn tui_quota_tier_seven_day() -> &'static str {
if is_chinese() {
"7天"
} else {
"7d"
}
}
pub fn tui_quota_tier_seven_day_opus() -> &'static str {
if is_chinese() {
"7天 Opus"
} else {
"7d Opus"
}
}
pub fn tui_quota_tier_seven_day_sonnet() -> &'static str {
if is_chinese() {
"7天 Sonnet"
} else {
"7d Sonnet"
}
}
pub fn tui_quota_tier_weekly_limit() -> &'static str {
if is_chinese() {
"周额度"
} else {
"weekly"
}
}
pub fn tui_quota_tier_premium() -> &'static str {
"premium"
}
pub fn tui_quota_tier_gemini_pro() -> &'static str {
"Gemini Pro"
}
pub fn tui_quota_tier_gemini_flash() -> &'static str {
"Gemini Flash"
}
pub fn tui_quota_tier_gemini_flash_lite() -> &'static str {
"Gemini Flash Lite"
}
pub fn tui_header_id() -> &'static str {
"ID"
}
pub fn tui_header_api_url() -> &'static str {
"API URL"
}
pub fn tui_header_directory() -> &'static str {
if is_chinese() {
"目录"
} else {
"Directory"
}
}
pub fn tui_header_repo() -> &'static str {
if is_chinese() {
"仓库"
} else {
"Repo"
}
}
pub fn tui_header_branch() -> &'static str {
if is_chinese() {
"分支"
} else {
"Branch"
}
}
pub fn tui_header_path() -> &'static str {
if is_chinese() {
"路径"
} else {
"Path"
}
}
pub fn tui_header_found_in() -> &'static str {
if is_chinese() {
"发现于"
} else {
"Found In"
}
}
pub fn tui_header_field() -> &'static str {
if is_chinese() {
"字段"
} else {
"Field"
}
}
pub fn tui_header_value() -> &'static str {
if is_chinese() {
"值"
} else {
"Value"
}
}
pub fn tui_header_claude_short() -> &'static str {
"C"
}
pub fn tui_header_codex_short() -> &'static str {
"X"
}
pub fn tui_header_gemini_short() -> &'static str {
"G"
}
pub fn tui_header_opencode_short() -> &'static str {
"O"
}
pub fn tui_label_id() -> &'static str {
"ID"
}
pub fn tui_label_api_url() -> &'static str {
"API URL"
}
pub fn tui_label_directory() -> &'static str {
if is_chinese() {
"目录"
} else {
"Directory"
}
}
pub fn tui_label_enabled_for() -> &'static str {
if is_chinese() {
"已启用"
} else {
"Enabled"
}
}
pub fn tui_label_repo() -> &'static str {
if is_chinese() {
"仓库"
} else {
"Repo"
}
}
pub fn tui_label_readme() -> &'static str {
if is_chinese() {
"README"
} else {
"README"
}
}
pub fn tui_label_base_url() -> &'static str {
if is_chinese() {
"API 请求地址"
} else {
"Base URL"
}
}
pub fn tui_label_api_key() -> &'static str {
if is_chinese() {
"API Key"
} else {
"API Key"
}
}
pub fn tui_label_claude_api_format() -> &'static str {
if is_chinese() {
"API 格式"
} else {
"API Format"
}
}
pub fn tui_claude_api_format_value(api_format: &str) -> &'static str {
match api_format {
"openai_chat" => {
if is_chinese() {
"OpenAI Chat Completions (需开启代理)"
} else {
"OpenAI Chat Completions (Requires proxy)"
}
}
"openai_responses" => {
if is_chinese() {
"OpenAI Responses API (需开启代理)"
} else {
"OpenAI Responses API (Requires proxy)"
}
}
_ => {
if is_chinese() {
"Anthropic Messages (原生)"
} else {
"Anthropic Messages (Native)"
}
}
}
}
pub fn tui_claude_api_format_requires_proxy_title() -> &'static str {
if is_chinese() {
"需开启代理"
} else {
"Proxy Required"
}
}
pub fn tui_claude_api_format_requires_proxy_message(api_format: &str) -> String {
let label = tui_claude_api_format_value(api_format);
if is_chinese() {
format!("已切换为 {label}。\n该格式需开启本地代理使用。\n请在主页按 P 打开本地代理。")
} else {
format!("Switched to {label}.\nThis format requires the local proxy.\nPress P on the home page to open local proxy.")
}
}
pub fn tui_claude_api_format_popup_title() -> &'static str {
if is_chinese() {
"API 格式"
} else {
"API Format"
}
}
pub fn tui_label_claude_model_config() -> &'static str {
if is_chinese() {
"Claude 模型配置"
} else {
"Claude Model Config"
}
}
pub fn tui_label_claude_hide_attribution() -> &'static str {
if is_chinese() {
"隐藏 AI 署名"
} else {
"Hide AI Attribution"
}
}
pub fn tui_label_provider_package() -> &'static str {
if is_chinese() {
"Provider / npm 包"
} else {
"Provider / npm"
}
}
pub fn tui_label_openclaw_api() -> &'static str {
if is_chinese() {
"API 协议"
} else {
"API Mode"
}
}
pub fn tui_label_openclaw_user_agent() -> &'static str {
if is_chinese() {
"发送 User-Agent"
} else {
"Send User-Agent"
}
}
pub fn tui_label_openclaw_models() -> &'static str {
if is_chinese() {
"模型列表"
} else {
"Models"
}
}
pub fn tui_label_openclaw_status() -> &'static str {
if is_chinese() {
"状态"
} else {
"Status"
}
}
pub fn tui_opencode_config_status_label() -> &'static str {
if is_chinese() {
"OpenCode 配置"
} else {
"OpenCode Config"
}
}
pub fn tui_label_provider_config_status() -> &'static str {
if is_chinese() {
"配置状态"
} else {
"Config Status"
}
}
pub fn tui_provider_config_count(in_config: usize, total: usize) -> String {
if is_chinese() {
format!("{in_config}/{total} 已添加")
} else {
format!("{in_config}/{total} in config")
}
}
pub fn tui_provider_status_in_config() -> &'static str {
if is_chinese() {
"已添加到配置"
} else {
"in config"
}
}
pub fn tui_provider_status_saved_only() -> &'static str {
if is_chinese() {
"仅已保存"
} else {
"saved only"
}
}
pub fn tui_provider_status_untracked() -> &'static str {
if is_chinese() {
"未跟踪"
} else {
"untracked"
}
}
pub fn tui_label_openclaw_model() -> &'static str {
if is_chinese() {
"模型"
} else {
"Model"
}
}
pub fn tui_openclaw_status_default() -> &'static str {
if is_chinese() {
"默认"
} else {
"default"
}
}
pub fn tui_openclaw_status_in_config_and_saved() -> &'static str {
if is_chinese() {
"配置中 + 已保存"
} else {
"in config + saved"
}
}
pub fn tui_openclaw_status_live_only() -> &'static str {
if is_chinese() {
"仅当前配置"
} else {
"live only"
}
}
pub fn tui_openclaw_status_saved_only() -> &'static str {
if is_chinese() {
"仅已保存"
} else {
"saved only"
}
}
pub fn tui_openclaw_status_untracked() -> &'static str {
if is_chinese() {
"未跟踪"
} else {
"untracked"
}
}
pub fn tui_openclaw_models_summary(total: usize) -> String {
if is_chinese() {
if total == 0 {
"未配置模型".to_string()
} else {
format!(
"{total} 个模型（1 主模型 + {} 回退）",
total.saturating_sub(1)
)
}
} else if total == 0 {
"No models configured".to_string()
} else {
format!(
"{total} models (1 primary + {} fallbacks)",
total.saturating_sub(1)
)
}
}
pub fn tui_openclaw_models_open_hint() -> &'static str {
if is_chinese() {
"按 Enter 编辑 OpenClaw 模型列表"
} else {
"Press Enter to edit OpenClaw models"
}
}
pub fn tui_openclaw_models_editor_title() -> &'static str {
if is_chinese() {
"OpenClaw 模型列表"
} else {
"OpenClaw Models"
}
}
pub fn tui_toast_json_must_be_array() -> &'static str {
if is_chinese() {
"JSON 必须是数组"
} else {
"JSON must be an array"
}
}
pub fn tui_label_opencode_model_id() -> &'static str {
if is_chinese() {
"主模型 ID"
} else {
"Main Model ID"
}
}
pub fn tui_label_opencode_model_name() -> &'static str {
if is_chinese() {
"主模型名称"
} else {
"Main Model Name"
}
}
pub fn tui_label_context_limit() -> &'static str {
if is_chinese() {
"上下文限制"
} else {
"Context Limit"
}
}
pub fn tui_label_output_limit() -> &'static str {
if is_chinese() {
"输出限制"
} else {
"Output Limit"
}
}
pub fn tui_label_command() -> &'static str {
if is_chinese() {
"命令"
} else {
"Command"
}
}
pub fn tui_label_mcp_type() -> &'static str {
if is_chinese() {
"连接类型"
} else {
"Transport"
}
}
pub fn tui_label_url() -> &'static str {
"URL"
}
pub fn tui_label_args() -> &'static str {
if is_chinese() {
"参数"
} else {
"Args"
}
}
pub fn tui_label_env() -> &'static str {
if is_chinese() {
"环境变量"
} else {
"Env"
}
}
pub fn tui_mcp_env_entry_count(count: usize) -> String {
if is_chinese() {
format!("{count} 项")
} else if count == 1 {
"1 entry".to_string()
} else {
format!("{count} entries")
}
}
pub fn tui_mcp_env_editor_hint() -> &'static str {
if is_chinese() {
"按 Enter 管理环境变量"
} else {
"Press Enter to manage env entries"
}
}
pub fn tui_mcp_type_editor_hint() -> &'static str {
if is_chinese() {
"按 Enter 选择连接类型"
} else {
"Press Enter to choose transport"
}
}
pub fn tui_mcp_env_key_label() -> &'static str {
if is_chinese() {
"键"
} else {
"Key"
}
}
pub fn tui_mcp_env_value_label() -> &'static str {
if is_chinese() {
"值"
} else {
"Value"
}
}
pub fn tui_label_app_claude() -> &'static str {
if is_chinese() {
"应用: Claude"
} else {
"App: Claude"
}
}
pub fn tui_label_app_codex() -> &'static str {
if is_chinese() {
"应用: Codex"
} else {
"App: Codex"
}
}
pub fn tui_label_app_gemini() -> &'static str {
if is_chinese() {
"应用: Gemini"
} else {
"App: Gemini"
}
}
pub fn tui_label_app_opencode() -> &'static str {
if is_chinese() {
"应用: OpenCode"
} else {
"App: OpenCode"
}
}
pub fn tui_form_templates_title() -> &'static str {
if is_chinese() {
"模板"
} else {
"Templates"
}
}
pub fn tui_form_common_config_button() -> &'static str {
if is_chinese() {
"通用配置"
} else {
"Common Config"
}
}
pub fn tui_form_attach_common_config() -> &'static str {
if is_chinese() {
"添加通用配置"
} else {
"Attach Common Config"
}
}
pub fn tui_form_fields_title() -> &'static str {
if is_chinese() {
"字段"
} else {
"Fields"
}
}
pub fn tui_form_json_title() -> &'static str {
"JSON"
}
pub fn tui_codex_auth_json_title() -> &'static str {
if is_chinese() {
"auth.json (JSON) *"
} else {
"auth.json (JSON) *"
}
}
pub fn tui_codex_config_toml_title() -> &'static str {
if is_chinese() {
"config.toml (TOML)"
} else {
"config.toml (TOML)"
}
}
pub fn tui_form_input_title() -> &'static str {
if is_chinese() {
"输入"
} else {
"Input"
}
}
pub fn tui_form_editing_title() -> &'static str {
if is_chinese() {
"编辑中"
} else {
"Editing"
}
}
pub fn tui_claude_model_config_popup_title() -> &'static str {
if is_chinese() {
"Claude 模型配置"
} else {
"Claude Model Configuration"
}
}
pub fn tui_claude_model_main_label() -> &'static str {
if is_chinese() {
"主模型"
} else {
"Main Model"
}
}
pub fn tui_claude_reasoning_model_label() -> &'static str {
if is_chinese() {
"推理模型 (Thinking)"
} else {
"Reasoning Model (Thinking)"
}
}
pub fn tui_claude_default_haiku_model_label() -> &'static str {
if is_chinese() {
"默认 Haiku 模型"
} else {
"Default Haiku Model"
}
}
pub fn tui_claude_default_sonnet_model_label() -> &'static str {
if is_chinese() {
"默认 Sonnet 模型"
} else {
"Default Sonnet Model"
}
}
pub fn tui_claude_default_opus_model_label() -> &'static str {
if is_chinese() {
"默认 Opus 模型"
} else {
"Default Opus Model"
}
}
pub fn tui_claude_model_config_summary(configured_count: usize) -> String {
if is_chinese() {
format!("已配置 {configured_count}/5")
} else {
format!("Configured {configured_count}/5")
}
}
pub fn tui_claude_model_config_open_hint() -> &'static str {
if is_chinese() {
"按 Enter 配置 Claude 模型"
} else {
"Press Enter to configure Claude models"
}
}
pub fn tui_hint_press() -> &'static str {
if is_chinese() {
"按 "
} else {
"Press "
}
}
pub fn tui_hint_auto_fetch_models_from_api() -> &'static str {
if is_chinese() {
" 从 API 自动获取模型。"
} else {
" to auto-fetch models from API."
}
}
pub fn tui_model_fetch_popup_title(fetching: bool) -> String {
if is_chinese() {
if fetching {
"选择模型 (获取中...)".to_string()
} else {
"选择模型".to_string()
}
} else {
if fetching {
"Select Model (Fetching...)".to_string()
} else {
"Select Model".to_string()
}
}
}
pub fn tui_model_fetch_search_placeholder() -> &'static str {
if is_chinese() {
"输入过滤 或 直接回车使用输入值..."
} else {
"Type to filter, or press Enter to use input..."
}
}
pub fn tui_model_fetch_search_title() -> &'static str {
if is_chinese() {
"模型搜索"
} else {
"Model Search"
}
}
pub fn tui_model_fetch_no_models() -> &'static str {
if is_chinese() {
"没有获取到模型 (可直接输入并在此回车)"
} else {
"No models found (type custom and press Enter)"
}
}
pub fn tui_model_fetch_no_matches() -> &'static str {
if is_chinese() {
"没有匹配结果 (可直接输入并在此回车)"
} else {
"No matching models (press Enter to use input)"
}
}
pub fn tui_model_fetch_error_hint(err: &str) -> String {
if is_chinese() {
format!("获取失败: {}", err)
} else {
format!("Fetch failed: {}", err)
}
}
pub fn tui_provider_not_found() -> &'static str {
if is_chinese() {
"未找到该供应商。"
} else {
"Provider not found."
}
}
pub fn tui_provider_title() -> &'static str {
if is_chinese() {
"供应商"
} else {
"Provider"
}
}
pub fn tui_provider_detail_title() -> &'static str {
if is_chinese() {
"供应商详情"
} else {
"Provider Detail"
}
}
pub fn tui_provider_add_title() -> &'static str {
if is_chinese() {
"新增供应商"
} else {
"Add Provider"
}
}
pub fn tui_codex_official_no_api_key_tip() -> &'static str {
if is_chinese() {
"官方无需填写 API Key，直接保存即可。"
} else {
"Official provider doesn't require an API key. Just save."
}
}
pub fn tui_toast_codex_official_auth_json_disabled() -> &'static str {
if is_chinese() {
"官方模式下不支持编辑 auth.json（切换时会移除）。"
} else {
"auth.json editing is disabled for the official provider (it will be removed on switch)."
}
}
pub fn tui_provider_edit_title(name: &str) -> String {
if is_chinese() {
format!("编辑供应商: {name}")
} else {
format!("Edit Provider: {name}")
}
}
pub fn tui_provider_detail_keys() -> &'static str {
if is_chinese() {
"按键：s=切换 e=编辑 t=测速 c=健康检查"
} else {
"Keys: s=switch e=edit t=speedtest c=stream check"
}
}
pub fn tui_key_switch() -> &'static str {
if is_chinese() {
"切换"
} else {
"switch"
}
}
pub fn tui_key_add_remove() -> &'static str {
if is_chinese() {
"添加/移除"
} else {
"add/remove"
}
}
pub fn tui_key_set_default() -> &'static str {
if is_chinese() {
"设为默认"
} else {
"set default"
}
}
pub fn tui_key_edit() -> &'static str {
if is_chinese() {
"编辑"
} else {
"edit"
}
}
pub fn tui_key_speedtest() -> &'static str {
if is_chinese() {
"测速"
} else {
"speedtest"
}
}
pub fn tui_key_stream_check() -> &'static str {
if is_chinese() {
"健康检查"
} else {
"stream check"
}
}
pub fn tui_key_launch_temp() -> &'static str {
if is_chinese() {
"临时启动"
} else {
"launch temp"
}
}
pub fn tui_stream_check_status_operational() -> &'static str {
if is_chinese() {
"正常"
} else {
"operational"
}
}
pub fn tui_stream_check_status_degraded() -> &'static str {
if is_chinese() {
"降级"
} else {
"degraded"
}
}
pub fn tui_stream_check_status_failed() -> &'static str {
if is_chinese() {
"失败"
} else {
"failed"
}
}
pub fn tui_key_details() -> &'static str {
if is_chinese() {
"详情"
} else {
"details"
}
}
pub fn tui_key_view() -> &'static str {
if is_chinese() {
"查看"
} else {
"view"
}
}
pub fn tui_key_add() -> &'static str {
if is_chinese() {
"新增"
} else {
"add"
}
}
pub fn tui_key_delete() -> &'static str {
if is_chinese() {
"删除"
} else {
"delete"
}
}
pub fn tui_key_import() -> &'static str {
if is_chinese() {
"导入"
} else {
"import"
}
}
pub fn tui_key_install() -> &'static str {
if is_chinese() {
"安装"
} else {
"install"
}
}
pub fn tui_key_uninstall() -> &'static str {
if is_chinese() {
"卸载"
} else {
"uninstall"
}
}
pub fn tui_key_discover() -> &'static str {
if is_chinese() {
"发现"
} else {
"discover"
}
}
pub fn tui_key_unmanaged() -> &'static str {
if is_chinese() {
"已有"
} else {
"existing"
}
}
pub fn tui_key_repos() -> &'static str {
if is_chinese() {
"仓库"
} else {
"repos"
}
}
pub fn tui_key_sync() -> &'static str {
if is_chinese() {
"同步"
} else {
"sync"
}
}
pub fn tui_key_sync_method() -> &'static str {
if is_chinese() {
"同步方式"
} else {
"sync method"
}
}
pub fn tui_key_search() -> &'static str {
if is_chinese() {
"搜索"
} else {
"search"
}
}
pub fn tui_key_refresh() -> &'static str {
if is_chinese() {
"刷新"
} else {
"refresh"
}
}
pub fn tui_key_start_proxy() -> &'static str {
if is_chinese() {
"启动代理"
} else {
"start proxy"
}
}
pub fn tui_key_stop_proxy() -> &'static str {
if is_chinese() {
"停止代理"
} else {
"stop proxy"
}
}
pub fn tui_key_proxy_on() -> &'static str {
if is_chinese() {
"代理开"
} else {
"proxy on"
}
}
pub fn tui_key_proxy_off() -> &'static str {
if is_chinese() {
"代理关"
} else {
"proxy off"
}
}
pub fn tui_key_focus() -> &'static str {
if is_chinese() {
"切换窗口"
} else {
"next pane"
}
}
pub fn tui_key_toggle() -> &'static str {
if is_chinese() {
"启用/禁用"
} else {
"toggle"
}
}
pub fn tui_key_apps() -> &'static str {
if is_chinese() {
"应用"
} else {
"apps"
}
}
pub fn tui_key_activate() -> &'static str {
if is_chinese() {
"激活"
} else {
"activate"
}
}
pub fn tui_key_deactivate() -> &'static str {
if is_chinese() {
"取消激活"
} else {
"deactivate"
}
}
pub fn tui_key_open() -> &'static str {
if is_chinese() {
"打开"
} else {
"open"
}
}
pub fn tui_key_open_directory() -> &'static str {
if is_chinese() {
"打开目录"
} else {
"open dir"
}
}
pub fn tui_key_create() -> &'static str {
if is_chinese() {
"新建"
} else {
"create"
}
}
pub fn tui_key_rename() -> &'static str {
if is_chinese() {
"重命名"
} else {
"rename"
}
}
pub fn tui_key_apply() -> &'static str {
if is_chinese() {
"应用"
} else {
"apply"
}
}
pub fn tui_key_edit_snippet() -> &'static str {
if is_chinese() {
"编辑片段"
} else {
"edit snippet"
}
}
pub fn tui_key_close() -> &'static str {
if is_chinese() {
"关闭"
} else {
"close"
}
}
pub fn tui_key_exit() -> &'static str {
if is_chinese() {
"退出"
} else {
"exit"
}
}
pub fn tui_key_cancel() -> &'static str {
if is_chinese() {
"取消"
} else {
"cancel"
}
}
pub fn tui_key_submit() -> &'static str {
if is_chinese() {
"提交"
} else {
"submit"
}
}
pub fn tui_key_yes() -> &'static str {
if is_chinese() {
"确认"
} else {
"confirm"
}
}
pub fn tui_key_no() -> &'static str {
if is_chinese() {
"返回"
} else {
"back"
}
}
pub fn tui_key_scroll() -> &'static str {
if is_chinese() {
"滚动"
} else {
"scroll"
}
}
pub fn tui_key_restore() -> &'static str {
if is_chinese() {
"恢复"
} else {
"restore"
}
}
pub fn tui_key_takeover() -> &'static str {
if is_chinese() {
"接管"
} else {
"take over"
}
}
pub fn tui_key_save() -> &'static str {
if is_chinese() {
"保存"
} else {
"save"
}
}
pub fn tui_key_external_editor() -> &'static str {
if is_chinese() {
"外部编辑器"
} else {
"external editor"
}
}
pub fn tui_key_save_and_exit() -> &'static str {
if is_chinese() {
"保存并退出"
} else {
"save & exit"
}
}
pub fn tui_key_exit_without_save() -> &'static str {
if is_chinese() {
"不保存退出"
} else {
"exit w/o save"
}
}
pub fn tui_key_edit_mode() -> &'static str {
if is_chinese() {
"编辑"
} else {
"edit"
}
}
pub fn tui_key_clear() -> &'static str {
if is_chinese() {
"清除"
} else {
"clear"
}
}
pub fn tui_key_move() -> &'static str {
if is_chinese() {
"移动"
} else {
"move"
}
}
pub fn tui_key_exit_edit() -> &'static str {
if is_chinese() {
"退出编辑"
} else {
"exit edit"
}
}
pub fn tui_key_select() -> &'static str {
if is_chinese() {
"选择"
} else {
"select"
}
}
pub fn tui_key_fetch_model() -> &'static str {
if is_chinese() {
"获取模型"
} else {
"fetch model"
}
}
pub fn tui_key_deactivate_active() -> &'static str {
if is_chinese() {
"取消激活(当前)"
} else {
"deactivate active"
}
}
pub fn tui_provider_list_keys() -> &'static str {
if is_chinese() {
"按键：a=新增 e=编辑 Enter=详情 s=切换 /=搜索"
} else {
"Keys: a=add e=edit Enter=details s=switch /=filter"
}
}
pub fn tui_home_ascii_logo() -> &'static str {
// Same ASCII art across languages.
r#" _ _ _
___ ___ ___ __ __(_)| |_ ___ | |__
/ __|/ __|_____ / __|\ \ /\ / /| || __|/ __|| '_ \
| (__| (__|_____|\__ \ \ V V / | || |_| (__ | | | |
\___|\___| |___/ \_/\_/ |_| \__|\___||_| |_|
"#
}
pub fn tui_common_snippet_keys() -> &'static str {
if is_chinese() {
"按键：e=编辑 c=清除 a=应用 Esc=返回"
} else {
"Keys: e=edit c=clear a=apply Esc=back"
}
}
pub fn tui_view_config_app(app: &str) -> String {
if is_chinese() {
format!("应用: {}", app)
} else {
format!("App: {}", app)
}
}
pub fn tui_view_config_provider(provider: &str) -> String {
if is_chinese() {
format!("供应商: {}", provider)
} else {
format!("Provider: {}", provider)
}
}
pub fn tui_view_config_api_url(url: &str) -> String {
if is_chinese() {
format!("API URL: {}", url)
} else {
format!("API URL: {}", url)
}
}
pub fn tui_view_config_mcp_servers(enabled: usize, total: usize) -> String {
if is_chinese() {
format!("MCP 服务器: {} 启用 / {} 总数", enabled, total)
} else {
format!("MCP servers: {} enabled / {} total", enabled, total)
}
}
pub fn tui_view_config_prompts(active: &str) -> String {
if is_chinese() {
format!("提示词: {}", active)
} else {
format!("Prompts: {}", active)
}
}
pub fn tui_view_config_config_file(path: &str) -> String {
if is_chinese() {
format!("配置文件: {}", path)
} else {
format!("Config file: {}", path)
}
}
pub fn tui_settings_header_language() -> &'static str {
if is_chinese() {
"语言"
} else {
"Language"
}
}
pub fn tui_settings_header_setting() -> &'static str {
if is_chinese() {
"设置项"
} else {
"Setting"
}
}
pub fn tui_settings_header_value() -> &'static str {
if is_chinese() {
"值"
} else {
"Value"
}
}
pub fn tui_settings_title() -> &'static str {
if is_chinese() {
"设置"
} else {
"Settings"
}
}
pub fn tui_settings_visible_apps_label() -> &'static str {
if is_chinese() {
"可见应用"
} else {
"Visible Apps"
}
}
pub fn tui_settings_visible_apps_title() -> &'static str {
if is_chinese() {
"选择可见应用"
} else {
"Choose Visible Apps"
}
}
pub fn tui_settings_proxy_title() -> &'static str {
if is_chinese() {
"本地代理"
} else {
"Local Proxy"
}
}
pub fn tui_settings_proxy_listen_address_label() -> &'static str {
if is_chinese() {
"监听地址"
} else {
"Listen Address"
}
}
pub fn tui_settings_proxy_listen_port_label() -> &'static str {
if is_chinese() {
"监听端口"
} else {
"Listen Port"
}
}
pub fn tui_settings_proxy_listen_address_prompt() -> &'static str {
if is_chinese() {
"输入监听地址（如 127.0.0.1 / localhost / 0.0.0.0）"
} else {
"Enter listen address (for example 127.0.0.1 / localhost / 0.0.0.0)"
}
}
pub fn tui_settings_proxy_listen_port_prompt() -> &'static str {
if is_chinese() {
"输入监听端口（1024-65535）"
} else {
"Enter listen port (1024-65535)"
}
}
pub fn tui_settings_openclaw_config_dir_label() -> &'static str {
if is_chinese() {
"OpenClaw 配置目录"
} else {
"OpenClaw Config Directory"
}
}
pub fn tui_settings_openclaw_config_dir_prompt() -> &'static str {
if is_chinese() {
"输入 OpenClaw 配置目录；留空恢复默认 ~/.openclaw"
} else {
"Enter the OpenClaw config directory; leave empty to use ~/.openclaw"
}
}
pub fn tui_settings_openclaw_config_dir_default_value() -> &'static str {
"Default (~/.openclaw)"
}
pub fn tui_settings_proxy_restart_hint() -> &'static str {
if is_chinese() {
"修改监听地址或端口后，需先停止并重新开启本地代理才能生效"
} else {
"Changes to listen address or port require stopping and restarting the local proxy"
}
}
pub fn tui_settings_proxy_stop_before_edit_hint() -> &'static str {
if is_chinese() {
"请先停止本地代理，再修改监听地址或端口"
} else {
"Stop the local proxy before editing listen address or port"
}
}
pub fn tui_toast_proxy_listen_address_invalid() -> &'static str {
if is_chinese() {
"地址无效，请输入有效的 IPv4 地址、localhost 或 0.0.0.0"
} else {
"Invalid address. Enter a valid IPv4 address, localhost, or 0.0.0.0"
}
}
pub fn tui_toast_proxy_listen_port_invalid() -> &'static str {
if is_chinese() {
"端口无效，请输入 1024-65535 之间的数字"
} else {
"Invalid port. Enter a number between 1024 and 65535"
}
}
pub fn tui_toast_proxy_settings_saved() -> &'static str {
if is_chinese() {
"本地代理配置已保存。"
} else {
"Local proxy settings saved."
}
}
pub fn tui_toast_proxy_settings_restart_required() -> &'static str {
if is_chinese() {
"本地代理正在运行；新监听地址/端口会在重启代理后生效。"
} else {
"The local proxy is running; the new listen address/port will apply after restart."
}
}
pub fn tui_toast_proxy_settings_stop_before_edit() -> &'static str {
if is_chinese() {
"本地代理正在运行。请先停止代理，再修改监听地址或端口。"
} else {
"The local proxy is running. Stop it before editing listen address or port."
}
}
pub fn tui_toast_openclaw_config_dir_saved() -> &'static str {
if is_chinese() {
"OpenClaw 配置目录已保存。"
} else {
"OpenClaw config directory saved."
}
}
pub fn tui_toast_openclaw_config_dir_sync_skipped() -> &'static str {
if is_chinese() {
"目标 OpenClaw 目录尚未初始化；已保存设置，但暂未同步 live 配置。"
} else {
"The target OpenClaw directory is not initialized yet; the setting was saved but live sync was skipped."
}
}
pub fn tui_toast_openclaw_config_dir_sync_failed(err: &str) -> String {
if is_chinese() {
format!("OpenClaw 配置目录已保存，但同步 live 配置失败: {err}")
} else {
format!("OpenClaw config directory saved, but live sync failed: {err}")
}
}
pub fn tui_toast_visible_apps_zero_selection_warning() -> &'static str {
if is_chinese() {
"至少保留一个可见应用。"
} else {
"Keep at least one app visible."
}
}
pub fn tui_toast_visible_apps_saved() -> &'static str {
if is_chinese() {
"可见应用已保存。"
} else {
"Visible apps saved."
}
}
pub fn tui_config_title() -> &'static str {
if is_chinese() {
"配置"
} else {
"Configuration"
}
}
// ---------------------------------------------------------------------
// Ratatui TUI - Skills
// ---------------------------------------------------------------------
pub fn tui_skills_install_title() -> &'static str {
if is_chinese() {
"安装 Skill"
} else {
"Install Skill"
}
}
pub fn tui_skills_install_prompt() -> &'static str {
if is_chinese() {
"输入技能目录，或完整标识（owner/name:directory）："
} else {
"Enter a skill directory, or a full key (owner/name:directory):"
}
}
pub fn tui_skills_uninstall_title() -> &'static str {
if is_chinese() {
"卸载 Skill"
} else {
"Uninstall Skill"
}
}
pub fn tui_confirm_uninstall_skill_message(name: &str, directory: &str) -> String {
if is_chinese() {
format!("确认卸载 '{name}'（{directory}）？")
} else {
format!("Uninstall '{name}' ({directory})?")
}
}
pub fn tui_skills_discover_title() -> &'static str {
if is_chinese() {
"发现 Skills"
} else {
"Discover Skills"
}
}
pub fn tui_skills_discover_prompt() -> &'static str {
if is_chinese() {
"输入关键词（留空显示全部）："
} else {
"Enter a keyword (leave empty to show all):"
}
}
pub fn tui_skills_discover_query_empty() -> &'static str {
if is_chinese() {
"全部"
} else {
"all"
}
}
pub fn tui_skills_discover_hint() -> &'static str {
if is_chinese() {
"按 f 搜索仓库里的技能，按 r 管理技能仓库。"
} else {
"Press f to search skills from enabled repositories, or r to manage repositories."
}
}
pub fn tui_skills_repos_title() -> &'static str {
if is_chinese() {
"Skill 仓库"
} else {
"Skill Repositories"
}
}
pub fn tui_skills_repos_hint() -> &'static str {
if is_chinese() {
"技能发现会从这里已启用的仓库加载列表。"
} else {
"Skill discovery loads results from the repositories enabled here."
}
}
pub fn tui_skills_repos_empty() -> &'static str {
if is_chinese() {
"未配置任何 Skill 仓库。按 a 添加。"
} else {
"No skill repositories configured. Press a to add."
}
}
pub fn tui_skills_repos_add_title() -> &'static str {
if is_chinese() {
"添加仓库"
} else {
"Add Repository"
}
}
pub fn tui_skills_repos_add_prompt() -> &'static str {
if is_chinese() {
"输入 GitHub 仓库（owner/name，可选 @branch）或完整 URL："
} else {
"Enter a GitHub repository (owner/name, optional @branch) or a full URL:"
}
}
pub fn tui_skills_repos_remove_title() -> &'static str {
if is_chinese() {
"移除仓库"
} else {
"Remove Repository"
}
}
pub fn tui_confirm_remove_repo_message(owner: &str, name: &str) -> String {
let repo = format!("{owner}/{name}");
if is_chinese() {
format!("确认移除仓库 '{repo}'？")
} else {
format!("Remove repository '{repo}'?")
}
}
pub fn tui_skills_unmanaged_title() -> &'static str {
tui_skills_import_title()
}
pub fn tui_skills_import_title() -> &'static str {
if is_chinese() {
"导入已有技能"
} else {
"Import Existing Skills"
}
}
pub fn tui_skills_unmanaged_hint() -> &'static str {
tui_skills_import_description()
}
pub fn tui_skills_import_description() -> &'static str {
if is_chinese() {
"选择要导入到 CC Switch 统一管理的技能。"
} else {
"Select skills to import into CC Switch unified management."
}
}
pub fn tui_skills_unmanaged_empty() -> &'static str {
if is_chinese() {
"未发现可导入的技能。"
} else {
"No skills to import found."
}
}
pub fn tui_skills_detail_title() -> &'static str {
if is_chinese() {
"Skill 详情"
} else {
"Skill Detail"
}
}
pub fn tui_skill_not_found() -> &'static str {
if is_chinese() {
"未找到该 Skill。"
} else {
"Skill not found."
}
}
pub fn tui_skills_sync_method_label() -> &'static str {
if is_chinese() {
"同步方式"
} else {
"Sync"
}
}
pub fn tui_skills_sync_method_title() -> &'static str {
if is_chinese() {
"选择同步方式"
} else {
"Select Sync Method"
}
}
pub fn tui_skills_sync_method_name(method: crate::services::skill::SyncMethod) -> &'static str {
match method {
crate::services::skill::SyncMethod::Auto => {
if is_chinese() {
"自动（优先使用链接，失败时复制）"
} else {
"Automatic (prefer links, fall back to copy)"
}
}
crate::services::skill::SyncMethod::Symlink => {
if is_chinese() {
"仅链接"
} else {
"Links only"
}
}
crate::services::skill::SyncMethod::Copy => {
if is_chinese() {
"仅复制"
} else {
"Copy only"
}
}
}
}
pub fn tui_skills_installed_summary(installed: usize, enabled: usize, app: &str) -> String {
if is_chinese() {
format!("已安装: {installed} 当前应用({app})已启用: {enabled}")
} else {
format!("Installed: {installed} Enabled for {app}: {enabled}")
}
}
pub fn tui_skills_installed_counts(
claude: usize,
codex: usize,
gemini: usize,
opencode: usize,
) -> String {
if is_chinese() {
format!(
"已安装 · Claude: {claude} · Codex: {codex} · Gemini: {gemini} · OpenCode: {opencode}"
)
} else {
format!(
"Installed · Claude: {claude} · Codex: {codex} · Gemini: {gemini} · OpenCode: {opencode}"
)
}
}
pub fn tui_mcp_server_counts(
claude: usize,
codex: usize,
gemini: usize,
opencode: usize,
hermes: usize,
) -> String {
if is_chinese() {
format!(
"已安装 · Claude: {claude} · Codex: {codex} · Gemini: {gemini} · OpenCode: {opencode} · Hermes: {hermes}"
)
} else {
format!(
"Installed · Claude: {claude} · Codex: {codex} · Gemini: {gemini} · OpenCode: {opencode} · Hermes: {hermes}"
)
}
}
pub fn tui_mcp_action_import_existing() -> &'static str {
if is_chinese() {
"导入已有"
} else {
"Import Existing"
}
}
pub fn tui_skills_action_import_existing() -> &'static str {
if is_chinese() {
"导入已有"
} else {
"Import Existing"
}
}
pub fn tui_skills_empty_title() -> &'static str {
if is_chinese() {
"暂无已安装的技能"
} else {
"No installed skills"
}
}
pub fn tui_skills_empty_subtitle() -> &'static str {
if is_chinese() {
"从仓库发现并安装技能，或导入已有技能。"
} else {
"Discover and install skills from repositories, or import existing skills."
}
}
pub fn tui_skills_empty_hint() -> &'static str {
if is_chinese() {
"暂无已安装技能。按 f 发现新技能，或按 i 导入已有技能。"
} else {
"No installed skills. Press f to discover skills, or i to import existing skills."
}
}
pub fn tui_config_item_export() -> &'static str {
if is_chinese() {
"导出配置"
} else {
"Export Config"
}
}
pub fn tui_config_item_import() -> &'static str {
if is_chinese() {
"导入配置"
} else {
"Import Config"
}
}
pub fn tui_config_item_backup() -> &'static str {
if is_chinese() {
"备份配置"
} else {
"Backup Config"
}
}
pub fn tui_config_item_restore() -> &'static str {
if is_chinese() {
"恢复配置"
} else {
"Restore Config"
}
}
pub fn tui_config_item_validate() -> &'static str {
if is_chinese() {
"验证配置"
} else {
"Validate Config"
}
}
pub fn tui_config_item_common_snippet() -> &'static str {
if is_chinese() {
"通用配置片段"
} else {
"Common Config Snippet"
}
}
pub fn tui_config_item_proxy() -> &'static str {
if is_chinese() {
"本地代理"
} else {
"Local Proxy"
}
}
pub fn tui_config_item_openclaw_env() -> &'static str {
if is_chinese() {
"环境变量"
} else {
"Env Variables"
}
}
pub fn tui_config_item_openclaw_workspace() -> &'static str {
if is_chinese() {
"Workspace 文件管理"
} else {
"Workspace Files"
}
}
pub fn tui_config_item_openclaw_tools() -> &'static str {
if is_chinese() {
"工具权限"
} else {
"Tool Permissions"
}
}
pub fn tui_config_item_openclaw_agents() -> &'static str {
if is_chinese() {
"Agents 配置"
} else {
"Agents Config"
}
}
pub fn tui_config_item_webdav_sync() -> &'static str {
if is_chinese() {
"WebDAV 同步"
} else {
"WebDAV Sync"
}
}
pub fn tui_config_item_webdav_settings() -> &'static str {
if is_chinese() {
"WebDAV 同步设置（JSON）"
} else {
"WebDAV Sync Settings (JSON)"
}
}
pub fn tui_config_item_webdav_check_connection() -> &'static str {
if is_chinese() {
"WebDAV 检查连接"
} else {
"WebDAV Check Connection"
}
}
pub fn tui_config_item_webdav_upload() -> &'static str {
if is_chinese() {
"WebDAV 上传到远端"
} else {
"WebDAV Upload to Remote"
}
}
pub fn tui_config_item_webdav_download() -> &'static str {
if is_chinese() {
"WebDAV 下载到本地"
} else {
"WebDAV Download to Local"
}
}
pub fn tui_config_item_webdav_reset() -> &'static str {
if is_chinese() {
"重置 WebDAV 配置"
} else {
"Reset WebDAV Settings"
}
}
pub fn tui_config_item_webdav_jianguoyun_quick_setup() -> &'static str {
if is_chinese() {
"坚果云一键配置"
} else {
"Jianguoyun Quick Setup"
}
}
pub fn tui_webdav_settings_editor_title() -> &'static str {
if is_chinese() {
"编辑 WebDAV 同步设置（JSON）"
} else {
"Edit WebDAV Sync Settings (JSON)"
}
}
pub fn tui_config_webdav_title() -> &'static str {
if is_chinese() {
"WebDAV 同步"
} else {
"WebDAV Sync"
}
}
pub fn tui_openclaw_config_env_title() -> &'static str {
tui_config_item_openclaw_env()
}
pub fn tui_openclaw_workspace_title() -> &'static str {
tui_config_item_openclaw_workspace()
}
pub fn tui_openclaw_workspace_files_block_title() -> &'static str {
if is_chinese() {
"Workspace 文件"
} else {
"Workspace Files"
}
}
pub fn tui_openclaw_workspace_directory_label() -> &'static str {
if is_chinese() {
"工作区目录"
} else {
"Workspace directory"
}
}
pub fn tui_openclaw_workspace_daily_memory_label() -> &'static str {
if is_chinese() {
"Daily Memory"
} else {
"Daily Memory"
}
}
pub fn tui_openclaw_workspace_daily_memory_count(count: usize) -> String {
if is_chinese() {
format!("{count} 个文件")
} else if count == 1 {
"1 file".to_string()
} else {
format!("{count} files")
}
}
pub fn tui_openclaw_workspace_status_exists() -> &'static str {
if is_chinese() {
"已存在"
} else {
"Exists"
}
}
pub fn tui_openclaw_workspace_status_missing() -> &'static str {
if is_chinese() {
"缺失"
} else {
"Missing"
}
}
pub fn tui_openclaw_config_tools_title() -> &'static str {
tui_config_item_openclaw_tools()
}
pub fn tui_openclaw_tools_description() -> &'static str {
if is_chinese() {
"管理 openclaw.json 中的工具权限配置（允许/拒绝列表）"
} else {
"Manage tool permissions in openclaw.json (allow/deny lists)"
}
}
pub fn tui_openclaw_tools_profile_block_title() -> &'static str {
if is_chinese() {
"权限档位"
} else {
"Permission Profile"
}
}
pub fn tui_openclaw_tools_rules_block_title() -> &'static str {
if is_chinese() {
"规则列表"
} else {
"Rule Lists"
}
}
pub fn tui_openclaw_tools_profile_label() -> &'static str {
if is_chinese() {
"配置档位"
} else {
"Profile"
}
}
pub fn tui_openclaw_tools_profile_unset() -> &'static str {
if is_chinese() {
"未设置"
} else {
"Not set"
}
}
pub fn tui_openclaw_tools_profile_minimal() -> &'static str {
if is_chinese() {
"最小权限"
} else {
"Minimal"
}
}
pub fn tui_openclaw_tools_profile_coding() -> &'static str {
if is_chinese() {
"编码"
} else {
"Coding"
}
}
pub fn tui_openclaw_tools_profile_messaging() -> &'static str {
if is_chinese() {
"对话"
} else {
"Messaging"
}
}
pub fn tui_openclaw_tools_profile_full() -> &'static str {
if is_chinese() {
"完全访问"
} else {
"Full"
}
}
pub fn tui_openclaw_tools_unsupported_profile_title() -> &'static str {
if is_chinese() {
"检测到不受支持的工具配置"
} else {
"Unsupported tools profile detected"
}
}
pub fn tui_openclaw_tools_unsupported_profile_description(value: &str) -> String {
if is_chinese() {
format!(
"当前 tools.profile 的值“{value}”不在 OpenClaw 支持列表内。在你手动选择新值之前，它会被保留。"
)
} else {
format!(
"The current tools.profile value '{value}' is not in the supported OpenClaw list. It will be preserved until you choose a new value."
)
}
}
pub fn tui_openclaw_tools_unsupported_profile_label() -> &'static str {
if is_chinese() {
"不受支持"
} else {
"unsupported"
}
}
pub fn tui_openclaw_tools_allow_list_label() -> &'static str {
if is_chinese() {
"允许列表"
} else {
"Allow List"
}
}
pub fn tui_openclaw_tools_deny_list_label() -> &'static str {
if is_chinese() {
"拒绝列表"
} else {
"Deny List"
}
}
pub fn tui_openclaw_tools_pattern_placeholder() -> &'static str {
if is_chinese() {
"工具名称或模式"
} else {
"Tool name or pattern"
}
}
pub fn tui_openclaw_tools_add_allow_rule() -> &'static str {
if is_chinese() {
"+ 添加允许规则"
} else {
"+ Add allow rule"
}
}
pub fn tui_openclaw_tools_add_deny_rule() -> &'static str {
if is_chinese() {
"+ 添加拒绝规则"
} else {
"+ Add deny rule"
}
}
pub fn tui_openclaw_tools_extra_fields_label() -> &'static str {
if is_chinese() {
"保留的其他字段"
} else {
"Preserved extra fields"
}
}
pub fn tui_openclaw_tools_save_label() -> &'static str {
if is_chinese() {
"保存"
} else {
"Save"
}
}
pub fn tui_openclaw_tools_load_failed_message() -> &'static str {
if is_chinese() {
"当前 tools 配置无法加载；请先修复上方解析警告，再编辑工具权限。"
} else {
"The current tools section could not be loaded. Fix the parse warning above before editing tool permissions."
}
}
pub fn tui_toast_openclaw_tools_save_result(success: bool) -> &'static str {
if success {
if is_chinese() {
"工具权限已保存"
} else {
"Tool permissions saved"
}
} else if is_chinese() {
"保存工具权限失败"
} else {
"Failed to save tool permissions"
}
}
pub fn tui_toast_openclaw_tools_save_failed_detail(err: &str) -> String {
if is_chinese() {
format!("保存工具权限失败: {err}")
} else {
format!("Failed to save tool permissions: {err}")
}
}
pub fn tui_toast_openclaw_tools_save_blocked_parse_error() -> &'static str {
if is_chinese() {
"请先修复 OpenClaw 工具配置解析警告，再保存工具权限"
} else {
"Fix OpenClaw tools parse warnings before saving tool permissions"
}
}
pub fn tui_toast_openclaw_tools_rule_empty() -> &'static str {
if is_chinese() {
"工具规则不能为空"
} else {
"Tool rule cannot be empty"
}
}
pub fn tui_openclaw_agents_description() -> &'static str {
if is_chinese() {
"管理 openclaw.json 中的 agents.defaults 配置（默认模型、运行参数等）"
} else {
"Manage agents.defaults in openclaw.json (default model, runtime parameters, etc.)"
}
}
pub fn tui_openclaw_agents_model_section() -> &'static str {
if is_chinese() {
"模型配置"
} else {
"Model Configuration"
}
}
pub fn tui_openclaw_agents_primary_model() -> &'static str {
if is_chinese() {
"默认模型"
} else {
"Default Model"
}
}
pub fn tui_openclaw_agents_not_set() -> &'static str {
if is_chinese() {
"未设置"
} else {
"Not set"
}
}
pub fn tui_openclaw_agents_fallback_models() -> &'static str {
if is_chinese() {
"回退模型"
} else {
"Fallback Models"
}
}
pub fn tui_openclaw_agents_add_fallback() -> &'static str {
if is_chinese() {
"添加回退模型"
} else {
"Add fallback model"
}
}
pub fn tui_openclaw_agents_add_fallback_disabled() -> &'static str {
if is_chinese() {
"没有可添加的回退模型了"
} else {
"No fallback models available to add"
}
}
pub fn tui_openclaw_agents_not_configured_suffix() -> &'static str {
if is_chinese() {
"供应商未配置"
} else {
"not configured"
}
}
pub fn tui_openclaw_agents_not_in_list(value: &str) -> String {
if is_chinese() {
format!("{value} (供应商未配置)")
} else {
format!("{value} (not configured)")
}
}
pub fn tui_openclaw_agents_runtime_section() -> &'static str {
if is_chinese() {
"运行参数"
} else {
"Runtime Parameters"
}
}
pub fn tui_openclaw_agents_workspace() -> &'static str {
if is_chinese() {
"工作区路径"
} else {
"Workspace Path"
}
}
pub fn tui_openclaw_agents_timeout() -> &'static str {
if is_chinese() {
"超时时间（秒）"
} else {
"Timeout (seconds)"
}
}
pub fn tui_openclaw_agents_context_tokens() -> &'static str {
if is_chinese() {
"上下文 Token 数"
} else {
"Context Tokens"
}
}
pub fn tui_openclaw_agents_max_concurrent() -> &'static str {
if is_chinese() {
"最大并发数"
} else {
"Max Concurrent"
}
}
pub fn tui_openclaw_agents_preserved_non_standard_value(value: &str) -> String {
if is_chinese() {
format!("{value}（已保留的非标准值）")
} else {
format!("{value} (preserved non-standard value)")
}
}
pub fn tui_openclaw_agents_preserved_runtime_notice() -> &'static str {
if is_chinese() {
"非标准运行参数会在你替换它们之前保持原样保存。"
} else {
"Non-standard runtime values are preserved until you replace them."
}
}
pub fn tui_openclaw_agents_preserved_fields_label() -> &'static str {
if is_chinese() {
"保留字段"
} else {
"Preserved Fields"
}
}
pub fn tui_openclaw_agents_legacy_timeout_title() -> &'static str {
if is_chinese() {
"检测到旧版超时字段"
} else {
"Legacy timeout detected"
}
}
pub fn tui_openclaw_agents_legacy_timeout_description() -> &'static str {
if is_chinese() {
"当前配置仍在使用 agents.defaults.timeout。保存本页面时会迁移为 timeoutSeconds。"
} else {
"This config still uses agents.defaults.timeout. Saving here will migrate it to timeoutSeconds."
}
}
pub fn tui_openclaw_agents_legacy_timeout_invalid_description() -> &'static str {
if is_chinese() {
"当前配置仍在使用 agents.defaults.timeout，但该值无法自动迁移。请先改为数字，或清空该字段后再保存。"
} else {
"This config still uses agents.defaults.timeout, but the current value cannot be migrated automatically. Change it to a number or clear the field before saving."
}
}
pub fn tui_openclaw_agents_load_failed_message() -> &'static str {
if is_chinese() {
"当前 agents.defaults 配置无法加载；请先修复上方解析警告，再编辑 Agents 配置。"
} else {
"The current agents.defaults section could not be loaded. Fix the parse warning above before editing agents defaults."
}
}
pub fn tui_openclaw_agents_save_label() -> &'static str {
if is_chinese() {
"保存"
} else {
"Save"
}
}
pub fn tui_toast_openclaw_agents_save_result(success: bool) -> &'static str {
if success {
if is_chinese() {
"Agents 配置已保存"
} else {
"Agents config saved"
}
} else if is_chinese() {
"保存 Agents 配置失败"
} else {
"Failed to save agents config"
}
}
pub fn tui_toast_openclaw_agents_save_failed_detail(err: &str) -> String {
if is_chinese() {
format!("保存 Agents 配置失败: {err}")
} else {
format!("Failed to save agents config: {err}")
}
}
pub fn tui_toast_openclaw_agents_save_blocked_parse_error() -> &'static str {
if is_chinese() {
"请先修复 OpenClaw agents.defaults 解析警告，再保存 Agents 配置"
} else {
"Fix OpenClaw agents parse warnings before saving agents defaults"
}
}
pub fn tui_toast_openclaw_agents_save_blocked_legacy_timeout() -> &'static str {
if is_chinese() {
"请先处理 agents.defaults.timeout，再保存 Agents 配置"
} else {
"Resolve agents.defaults.timeout before saving agents config"
}
}
pub fn tui_openclaw_config_agents_title() -> &'static str {
tui_config_item_openclaw_agents()
}
pub fn tui_openclaw_config_env_editor_title() -> &'static str {
if is_chinese() {
"编辑环境变量 (JSON)"
} else {
"Edit Env Variables (JSON)"
}
}
pub fn tui_openclaw_config_env_description() -> &'static str {
if is_chinese() {
"管理 openclaw.json 中的环境变量映射；保存时会写回 env.vars。"
} else {
"Manage the environment variable map in openclaw.json; saving writes back to env.vars."
}
}
pub fn tui_openclaw_config_env_empty() -> &'static str {
if is_chinese() {
"未配置环境变量"
} else {
"No environment variables configured"
}
}
pub fn tui_openclaw_config_tools_editor_title() -> &'static str {
if is_chinese() {
"编辑工具权限 (JSON)"
} else {
"Edit Tool Permissions (JSON)"
}
}
pub fn tui_openclaw_config_agents_editor_title() -> &'static str {
if is_chinese() {
"编辑 Agents 配置 (JSON)"
} else {
"Edit Agents Config (JSON)"
}
}
pub fn tui_openclaw_config_warning_title() -> &'static str {
if is_chinese() {
"OpenClaw 配置告警"
} else {
"OpenClaw Health Warnings"
}
}
pub fn tui_openclaw_config_file_label() -> &'static str {
if is_chinese() {
"配置文件"
} else {
"Config file"
}
}
pub fn tui_openclaw_config_section_label() -> &'static str {
if is_chinese() {
"当前配置"
} else {
"Section"
}
}
pub fn tui_openclaw_config_warning_state_label() -> &'static str {
if is_chinese() {
"告警状态"
} else {
"Warnings"
}
}
pub fn tui_openclaw_config_warning_present() -> &'static str {
if is_chinese() {
"发现告警"
} else {
"Warnings detected"
}
}
pub fn tui_openclaw_config_warning_clean() -> &'static str {
if is_chinese() {
"正常"
} else {
"Healthy"
}
}
pub fn tui_openclaw_config_path_not_available() -> &'static str {
if is_chinese() {
"不可用"
} else {
"n/a"
}
}
pub fn tui_toast_openclaw_config_saved(section: &str) -> String {
if is_chinese() {
format!("已保存 {section}")
} else {
format!("Saved {section}")
}
}
pub fn tui_openclaw_workspace_editor_title(filename: &str) -> String {
if is_chinese() {
format!("编辑 Workspace 文件: {filename}")
} else {
format!("Edit Workspace File: {filename}")
}
}
pub fn tui_openclaw_workspace_saved(filename: &str) -> String {
if is_chinese() {
format!("已保存 Workspace 文件: {filename}")
} else {
format!("Saved workspace file: {filename}")
}
}
pub fn tui_openclaw_workspace_open_failed(filename: &str, detail: &str) -> String {
if is_chinese() {
format!("打开 Workspace 文件失败 {filename}: {detail}")
} else {
format!("Failed to open workspace file {filename}: {detail}")
}
}
pub fn tui_openclaw_workspace_save_failed(filename: &str, detail: &str) -> String {
if is_chinese() {
format!("保存 Workspace 文件失败 {filename}: {detail}")
} else {
format!("Failed to save workspace file {filename}: {detail}")
}
}
pub fn tui_openclaw_workspace_refresh_failed(detail: &str) -> String {
if is_chinese() {
format!("刷新 Workspace 状态失败: {detail}")
} else {
format!("Failed to refresh workspace state: {detail}")
}
}
pub fn tui_openclaw_workspace_directory_open_failed(detail: &str) -> String {
if is_chinese() {
format!("打开 Workspace 目录失败: {detail}")
} else {
format!("Failed to open workspace directory: {detail}")
}
}
pub fn tui_openclaw_daily_memory_title() -> &'static str {
if is_chinese() {
"Daily Memory"
} else {
"Daily Memory"
}
}
pub fn tui_openclaw_daily_memory_directory_label() -> &'static str {
if is_chinese() {
"Memory 目录"
} else {
"Memory directory"
}
}
pub fn tui_openclaw_daily_memory_create_title() -> &'static str {
if is_chinese() {
"新建 Daily Memory"
} else {
"Create Daily Memory"
}
}
pub fn tui_openclaw_daily_memory_create_prompt() -> &'static str {
if is_chinese() {
"输入文件名（YYYY-MM-DD.md）："
} else {
"Enter a filename (YYYY-MM-DD.md):"
}
}
pub fn tui_openclaw_daily_memory_invalid_filename() -> &'static str {
if is_chinese() {
"文件名无效，请使用 YYYY-MM-DD.md。"
} else {
"Invalid filename. Use YYYY-MM-DD.md."
}
}
pub fn tui_openclaw_daily_memory_editor_title(filename: &str) -> String {
if is_chinese() {
format!("编辑 Daily Memory: {filename}")
} else {
format!("Edit Daily Memory: {filename}")
}
}
pub fn tui_openclaw_daily_memory_saved(filename: &str) -> String {
if is_chinese() {
format!("已保存 Daily Memory: {filename}")
} else {
format!("Saved daily memory: {filename}")
}
}
pub fn tui_openclaw_daily_memory_open_failed(filename: &str, detail: &str) -> String {
if is_chinese() {
format!("打开 Daily Memory 失败 {filename}: {detail}")
} else {
format!("Failed to open daily memory {filename}: {detail}")
}
}
pub fn tui_openclaw_daily_memory_save_failed(filename: &str, detail: &str) -> String {
if is_chinese() {
format!("保存 Daily Memory 失败 {filename}: {detail}")
} else {
format!("Failed to save daily memory {filename}: {detail}")
}
}
pub fn tui_openclaw_daily_memory_deleted(filename: &str) -> String {
if is_chinese() {
format!("已删除 Daily Memory: {filename}")
} else {
format!("Deleted daily memory: {filename}")
}
}
pub fn tui_openclaw_daily_memory_delete_failed(filename: &str, detail: &str) -> String {
if is_chinese() {
format!("删除 Daily Memory 失败 {filename}: {detail}")
} else {
format!("Failed to delete daily memory {filename}: {detail}")
}
}
pub fn tui_openclaw_daily_memory_search_failed(detail: &str) -> String {
if is_chinese() {
format!("搜索 Daily Memory 失败: {detail}")
} else {
format!("Failed to search daily memory: {detail}")
}
}
pub fn tui_openclaw_daily_memory_refresh_failed(detail: &str) -> String {
if is_chinese() {
format!("刷新 Daily Memory 列表失败: {detail}")
} else {
format!("Failed to refresh daily memory list: {detail}")
}
}
pub fn tui_openclaw_daily_memory_delete_title() -> &'static str {
if is_chinese() {
"删除 Daily Memory"
} else {
"Delete Daily Memory"
}
}
pub fn tui_openclaw_daily_memory_delete_message(filename: &str) -> String {
if is_chinese() {
format!("确认删除 {filename}？")
} else {
format!("Delete {filename}?")
}
}
pub fn tui_openclaw_memory_directory_open_failed(detail: &str) -> String {
if is_chinese() {
format!("打开 Memory 目录失败: {detail}")
} else {
format!("Failed to open memory directory: {detail}")
}
}
pub fn tui_openclaw_daily_memory_empty() -> &'static str {
if is_chinese() {
"还没有 Daily Memory 文件。按 a 新建。"
} else {
"No daily memory files yet. Press a to create one."
}
}
pub fn tui_openclaw_daily_memory_search_empty() -> &'static str {
if is_chinese() {
"没有匹配的 Daily Memory 文件。"
} else {
"No matching daily memory files."
}
}
pub fn tui_webdav_jianguoyun_setup_title() -> &'static str {
if is_chinese() {
"坚果云一键配置"
} else {
"Jianguoyun Quick Setup"
}
}
pub fn tui_webdav_jianguoyun_username_prompt() -> &'static str {
if is_chinese() {
"请输入坚果云账号（通常是邮箱）："
} else {
"Enter your Jianguoyun account (usually email):"
}
}
pub fn tui_webdav_jianguoyun_app_password_prompt() -> &'static str {
if is_chinese() {
"请输入坚果云第三方应用密码："
} else {
"Enter your Jianguoyun app password:"
}
}
pub fn tui_webdav_loading_title_check_connection() -> &'static str {
if is_chinese() {
"WebDAV 检查连接"
} else {
"WebDAV Check Connection"
}
}
pub fn tui_webdav_loading_title_upload() -> &'static str {
if is_chinese() {
"WebDAV 上传"
} else {
"WebDAV Upload"
}
}
pub fn tui_webdav_loading_title_download() -> &'static str {
if is_chinese() {
"WebDAV 下载"
} else {
"WebDAV Download"
}
}
pub fn tui_webdav_loading_title_quick_setup() -> &'static str {
if is_chinese() {
"坚果云一键配置"
} else {
"Jianguoyun Quick Setup"
}
}
pub fn tui_webdav_loading_message() -> &'static str {
if is_chinese() {
"正在处理 WebDAV 请求，请稍候…"
} else {
"Processing WebDAV request, please wait..."
}
}
pub fn tui_config_item_reset() -> &'static str {
if is_chinese() {
"重置配置"
} else {
"Reset Config"
}
}
pub fn tui_config_item_show_full() -> &'static str {
if is_chinese() {
"查看完整配置"
} else {
"Show Full Config"
}
}
pub fn tui_config_item_show_path() -> &'static str {
if is_chinese() {
"显示配置路径"
} else {
"Show Config Path"
}
}
pub fn tui_hint_esc_close() -> &'static str {
if is_chinese() {
"Esc = 关闭"
} else {
"Esc = Close"
}
}
pub fn tui_hint_enter_submit_esc_cancel() -> &'static str {
if is_chinese() {
"Enter = 提交, Esc = 取消"
} else {
"Enter = Submit, Esc = Cancel"
}
}
pub fn tui_hint_enter_restore_esc_cancel() -> &'static str {
if is_chinese() {
"Enter = 恢复, Esc = 取消"
} else {
"Enter = restore, Esc = cancel"
}
}
pub fn tui_backup_picker_title() -> &'static str {
if is_chinese() {
"选择备份（Enter 恢复）"
} else {
"Select Backup (Enter to restore)"
}
}
pub fn tui_speedtest_running(url: &str) -> String {
if is_chinese() {
format!("正在测速: {}", url)
} else {
format!("Running: {}", url)
}
}
pub fn tui_speedtest_title_with_url(url: &str) -> String {
if is_chinese() {
format!("测速: {}", url)
} else {
format!("Speedtest: {}", url)
}
}
pub fn tui_stream_check_running(provider_name: &str) -> String {
if is_chinese() {
format!("正在检查: {}", provider_name)
} else {
format!("Checking: {}", provider_name)
}
}
pub fn tui_stream_check_title_with_provider(provider_name: &str) -> String {
if is_chinese() {
format!("健康检查: {}", provider_name)
} else {
format!("Stream Check: {}", provider_name)
}
}
pub fn tui_toast_provider_already_in_use() -> &'static str {
if is_chinese() {
"已在使用该供应商。"
} else {
"Already using this provider."
}
}
pub fn tui_toast_provider_cannot_delete_current() -> &'static str {
if is_chinese() {
"不能删除当前供应商。"
} else {
"Cannot delete current provider."
}
}
pub fn tui_toast_provider_cannot_remove_default_model() -> &'static str {
if is_chinese() {
"被当前默认模型引用的供应商不能直接从配置中移除。"
} else {
"A provider referenced by the current default model cannot be removed from config directly."
}
}
pub fn tui_toast_provider_default_requires_live_config() -> &'static str {
if is_chinese() {
"请先将该供应商添加到配置中，再设为默认。"
} else {
"Add this provider to config before setting it as default."
}
}
pub fn tui_toast_provider_default_model_missing() -> &'static str {
if is_chinese() {
"该供应商缺少可设为默认的主模型。"
} else {
"This provider has no primary model to set as default."
}
}
pub fn tui_toast_provider_removed_from_config() -> &'static str {
if is_chinese() {
"已从当前 OpenClaw 配置中移除该供应商。"
} else {
"Provider removed from the current OpenClaw config."
}
}
pub fn tui_toast_provider_added_to_app_config(app: &str) -> String {
if is_chinese() {
format!("已将该供应商添加到当前 {app} 配置。")
} else {
format!("Provider added to the current {app} config.")
}
}
pub fn tui_toast_provider_removed_from_app_config(app: &str) -> String {
if is_chinese() {
format!("已从当前 {app} 配置中移除该供应商。")
} else {
format!("Provider removed from the current {app} config.")
}
}
pub fn tui_toast_provider_set_as_default(model: &str) -> String {
if is_chinese() {
format!("已设为默认模型: {}", model)
} else {
format!("Set default model: {}", model)
}
}
pub fn tui_temp_launch_failed(message: &str) -> String {
if is_chinese() {
format!("临时启动失败: {}", message)
} else {
format!("Temporary launch failed: {}", message)
}
}
pub fn tui_confirm_delete_provider_title() -> &'static str {
if is_chinese() {
"删除供应商"
} else {
"Delete Provider"
}
}
pub fn tui_confirm_delete_provider_message(name: &str, id: &str) -> String {
if is_chinese() {
format!("确定删除供应商 '{}' ({})？", name, id)
} else {
format!("Delete provider '{}' ({})?", name, id)
}
}
pub fn tui_mcp_add_title() -> &'static str {
if is_chinese() {
"新增 MCP 服务器"
} else {
"Add MCP Server"
}
}
pub fn tui_mcp_edit_title(name: &str) -> String {
if is_chinese() {
format!("编辑 MCP 服务器: {}", name)
} else {
format!("Edit MCP Server: {}", name)
}
}
pub fn tui_mcp_apps_title(name: &str) -> String {
if is_chinese() {
format!("选择 MCP 应用: {}", name)
} else {
format!("Select MCP Apps: {}", name)
}
}
pub fn tui_mcp_type_title() -> &'static str {
if is_chinese() {
"选择 MCP 连接类型"
} else {
"Select MCP Transport"
}
}
pub fn tui_mcp_env_title() -> &'static str {
if is_chinese() {
"MCP 环境变量"
} else {
"MCP Env"
}
}
pub fn tui_mcp_env_add_entry_title() -> &'static str {
if is_chinese() {
"新增环境变量"
} else {
"Add Env Entry"
}
}
pub fn tui_mcp_env_edit_entry_title() -> &'static str {
if is_chinese() {
"编辑环境变量"
} else {
"Edit Env Entry"
}
}
pub fn tui_mcp_env_empty_state() -> &'static str {
if is_chinese() {
"暂无环境变量，按 a 新增。"
} else {
"No env entries yet. Press a to add one."
}
}
pub fn tui_skill_apps_title(name: &str) -> String {
if is_chinese() {
format!("选择 Skill 应用: {}", name)
} else {
format!("Select Skill Apps: {}", name)
}
}
pub fn tui_toast_provider_no_api_url() -> &'static str {
if is_chinese() {
"该供应商未配置 API URL。"
} else {
"No API URL configured for this provider."
}
}
pub fn tui_confirm_delete_mcp_title() -> &'static str {
if is_chinese() {
"删除 MCP 服务器"
} else {
"Delete MCP Server"
}
}
pub fn tui_confirm_delete_mcp_message(name: &str, id: &str) -> String {
if is_chinese() {
format!("确定删除 MCP 服务器 '{}' ({})？", name, id)
} else {
format!("Delete MCP server '{}' ({})?", name, id)
}
}
pub fn tui_prompt_title(name: &str) -> String {
if is_chinese() {
format!("提示词: {}", name)
} else {
format!("Prompt: {}", name)
}
}
pub fn tui_prompt_rename_title() -> &'static str {
if is_chinese() {
"重命名提示词"
} else {
"Rename Prompt"
}
}
pub fn tui_prompt_create_title() -> &'static str {
if is_chinese() {
"创建提示词"
} else {
"Create Prompt"
}
}
pub fn tui_prompt_create_prompt() -> &'static str {
if is_chinese() {
"输入提示词名称："
} else {
"Enter a prompt name:"
}
}
pub fn tui_prompt_rename_prompt() -> &'static str {
if is_chinese() {
"输入新的提示词名称："
} else {
"Enter a new prompt name:"
}
}
pub fn tui_toast_prompt_no_active_to_deactivate() -> &'static str {
if is_chinese() {
"没有可停用的活动提示词。"
} else {
"No active prompt to deactivate."
}
}
pub fn tui_toast_prompt_cannot_delete_active() -> &'static str {
if is_chinese() {
"不能删除正在启用的提示词。"
} else {
"Cannot delete the active prompt."
}
}
pub fn tui_confirm_delete_prompt_title() -> &'static str {
if is_chinese() {
"删除提示词"
} else {
"Delete Prompt"
}
}
pub fn tui_confirm_delete_prompt_message(name: &str, id: &str) -> String {
if is_chinese() {
format!("确定删除提示词 '{}' ({})？", name, id)
} else {
format!("Delete prompt '{}' ({})?", name, id)
}
}
pub fn tui_toast_prompt_edit_finished() -> &'static str {
if is_chinese() {
"提示词编辑完成"
} else {
"Prompt edit finished"
}
}
pub fn tui_toast_prompt_name_empty() -> &'static str {
if is_chinese() {
"提示词名称不能为空。"
} else {
"Prompt name cannot be empty."
}
}
pub fn tui_toast_prompt_not_found(id: &str) -> String {
if is_chinese() {
format!("未找到提示词：{}", id)
} else {
format!("Prompt not found: {}", id)
}
}
pub fn tui_config_paths_title() -> &'static str {
if is_chinese() {
"配置路径"
} else {
"Configuration Paths"
}
}
pub fn tui_config_paths_config_file(path: &str) -> String {
if is_chinese() {
format!("配置文件: {}", path)
} else {
format!("Config file: {}", path)
}
}
pub fn tui_config_paths_config_dir(path: &str) -> String {
if is_chinese() {
format!("配置目录: {}", path)
} else {
format!("Config dir: {}", path)
}
}
pub fn tui_error_failed_to_read_config(e: &str) -> String {
if is_chinese() {
format!("读取配置失败: {e}")
} else {
format!("Failed to read config: {e}")
}
}
pub fn tui_config_export_title() -> &'static str {
if is_chinese() {
"导出配置"
} else {
"Export Configuration"
}
}
pub fn tui_config_export_prompt() -> &'static str {
if is_chinese() {
"导出路径："
} else {
"Export path:"
}
}
pub fn tui_config_import_title() -> &'static str {
if is_chinese() {
"导入配置"
} else {
"Import Configuration"
}
}
pub fn tui_config_import_prompt() -> &'static str {
if is_chinese() {
"从路径导入："
} else {
"Import from path:"
}
}
pub fn tui_config_backup_title() -> &'static str {
if is_chinese() {
"备份配置"
} else {
"Backup Configuration"
}
}
pub fn tui_config_backup_prompt() -> &'static str {
if is_chinese() {
"可选名称（留空使用默认值）："
} else {
"Optional name (empty for default):"
}
}
pub fn tui_toast_no_backups_found() -> &'static str {
if is_chinese() {
"未找到备份。"
} else {
"No backups found."
}
}
pub fn tui_error_failed_to_read(e: &str) -> String {
if is_chinese() {
format!("读取失败: {e}")
} else {
format!("Failed to read: {e}")
}
}
pub fn tui_common_snippet_title(app: &str) -> String {
if is_chinese() {
format!("通用片段 ({})", app)
} else {
format!("Common Snippet ({})", app)
}
}
pub fn tui_config_reset_title() -> &'static str {
if is_chinese() {
"重置配置"
} else {
"Reset Configuration"
}
}
pub fn tui_config_reset_message() -> &'static str {
if is_chinese() {
"重置为默认配置？（这将覆盖当前配置）"
} else {
"Reset to default configuration? (This will overwrite your current config)"
}
}
pub fn tui_toast_export_path_empty() -> &'static str {
if is_chinese() {
"导出路径为空。"
} else {
"Export path is empty."
}
}
pub fn tui_toast_import_path_empty() -> &'static str {
if is_chinese() {
"导入路径为空。"
} else {
"Import path is empty."
}
}
pub fn tui_confirm_import_message(path: &str) -> String {
if is_chinese() {
format!("确认从 '{}' 导入？", path)
} else {
format!("Import from '{}'?", path)
}
}
pub fn tui_toast_command_empty() -> &'static str {
if is_chinese() {
"命令为空。"
} else {
"Command is empty."
}
}
pub fn tui_toast_url_empty() -> &'static str {
if is_chinese() {
"URL 为空。"
} else {
"URL is empty."
}
}
pub fn tui_toast_mcp_env_key_empty() -> &'static str {
if is_chinese() {
"环境变量 Key 不能为空。"
} else {
"Env key cannot be empty."
}
}
pub fn tui_toast_mcp_env_duplicate_key(key: &str) -> String {
if is_chinese() {
format!("环境变量 Key '{}' 已存在。", key)
} else {
format!("Env key '{key}' already exists.")
}
}
pub fn tui_confirm_restore_backup_title() -> &'static str {
if is_chinese() {
"恢复备份"
} else {
"Restore Backup"
}
}
pub fn tui_confirm_restore_backup_message(name: &str) -> String {
if is_chinese() {
format!("确认从备份 '{}' 恢复？", name)
} else {
format!("Restore from backup '{}'?", name)
}
}
pub fn tui_speedtest_line_url(url: &str) -> String {
format!("URL: {}", url)
}
pub fn tui_stream_check_line_provider(provider_name: &str) -> String {
if is_chinese() {
format!("供应商: {provider_name}")
} else {
format!("Provider: {provider_name}")
}
}
pub fn tui_stream_check_line_status(status: &str) -> String {
if is_chinese() {
format!("状态: {status}")
} else {
format!("Status: {status}")
}
}
pub fn tui_stream_check_line_response_time(response_time: &str) -> String {
if is_chinese() {
format!("耗时: {response_time}")
} else {
format!("Time: {response_time}")
}
}
pub fn tui_stream_check_line_http_status(status: &str) -> String {
if is_chinese() {
format!("HTTP: {status}")
} else {
format!("HTTP: {status}")
}
}
pub fn tui_stream_check_line_model(model: &str) -> String {
if is_chinese() {
format!("模型: {model}")
} else {
format!("Model: {model}")
}
}
pub fn tui_stream_check_line_retries(retries: &str) -> String {
if is_chinese() {
format!("重试: {retries}")
} else {
format!("Retries: {retries}")
}
}
pub fn tui_stream_check_line_message(message: &str) -> String {
if is_chinese() {
format!("信息: {message}")
} else {
format!("Message: {message}")
}
}
pub fn tui_speedtest_line_latency(latency: &str) -> String {
if is_chinese() {
format!("延迟: {latency}")
} else {
format!("Latency: {latency}")
}
}
pub fn tui_speedtest_line_status(status: &str) -> String {
if is_chinese() {
format!("状态: {status}")
} else {
format!("Status: {status}")
}
}
pub fn tui_speedtest_line_error(err: &str) -> String {
if is_chinese() {
format!("错误: {err}")
} else {
format!("Error: {err}")
}
}
pub fn tui_toast_speedtest_finished() -> &'static str {
if is_chinese() {
"测速完成。"
} else {
"Speedtest finished."
}
}
pub fn tui_toast_speedtest_failed(err: &str) -> String {
if is_chinese() {
format!("测速失败: {err}")
} else {
format!("Speedtest failed: {err}")
}
}
pub fn tui_toast_speedtest_unavailable(err: &str) -> String {
if is_chinese() {
format!("测速不可用: {err}")
} else {
format!("Speedtest unavailable: {err}")
}
}
pub fn tui_toast_speedtest_disabled() -> &'static str {
if is_chinese() {
"本次会话测速不可用。"
} else {
"Speedtest is disabled for this session."
}
}
pub fn tui_toast_local_env_check_unavailable(err: &str) -> String {
if is_chinese() {
format!("本地环境检查不可用: {err}")
} else {
format!("Local environment check unavailable: {err}")
}
}
pub fn tui_toast_local_env_check_disabled() -> &'static str {
if is_chinese() {
"本次会话本地环境检查不可用。"
} else {
"Local environment check is disabled for this session."
}
}
pub fn tui_toast_local_env_check_request_failed(err: &str) -> String {
if is_chinese() {
format!("本地环境检查刷新请求失败: {err}")
} else {
format!("Failed to enqueue local environment check: {err}")
}
}
pub fn tui_toast_speedtest_request_failed(err: &str) -> String {
if is_chinese() {
format!("测速请求失败: {err}")
} else {
format!("Failed to enqueue speedtest: {err}")
}
}
pub fn tui_toast_stream_check_finished() -> &'static str {
if is_chinese() {
"健康检查完成。"
} else {
"Stream check finished."
}
}
pub fn tui_toast_stream_check_failed(err: &str) -> String {
if is_chinese() {
format!("健康检查失败: {err}")
} else {
format!("Stream check failed: {err}")
}
}
pub fn tui_toast_stream_check_unavailable(err: &str) -> String {
if is_chinese() {
format!("健康检查不可用: {err}")
} else {
format!("Stream check unavailable: {err}")
}
}
pub fn tui_toast_stream_check_disabled() -> &'static str {
if is_chinese() {
"本次会话健康检查不可用。"
} else {
"Stream check is disabled for this session."
}
}
pub fn tui_toast_stream_check_request_failed(err: &str) -> String {
if is_chinese() {
format!("健康检查请求失败: {err}")
} else {
format!("Failed to enqueue stream check: {err}")
}
}
pub fn tui_toast_quota_not_available() -> &'static str {
if is_chinese() {
"当前供应商没有官方额度查询。"
} else {
"This provider has no official quota query."
}
}
pub fn tui_toast_quota_worker_unavailable(err: &str) -> String {
if is_chinese() {
format!("额度查询后台任务不可用: {err}")
} else {
format!("Quota worker unavailable: {err}")
}
}
pub fn tui_toast_quota_refresh_started(provider: &str) -> String {
if is_chinese() {
format!("正在刷新额度: {provider}")
} else {
format!("Refreshing quota: {provider}")
}
}
pub fn tui_toast_quota_refresh_finished(provider: &str) -> String {
if is_chinese() {
format!("额度已刷新: {provider}")
} else {
format!("Quota refreshed: {provider}")
}
}
pub fn tui_toast_quota_refresh_failed(err: &str) -> String {
if is_chinese() {
format!("额度刷新失败: {err}")
} else {
format!("Quota refresh failed: {err}")
}
}
pub fn tui_toast_skills_worker_unavailable(err: &str) -> String {
if is_chinese() {
format!("Skills 后台任务不可用: {err}")
} else {
format!("Skills worker unavailable: {err}")
}
}
pub fn tui_toast_webdav_worker_unavailable(err: &str) -> String {
if is_chinese() {
format!("WebDAV 后台任务不可用: {err}")
} else {
format!("WebDAV worker unavailable: {err}")
}
}
pub fn tui_toast_model_fetch_worker_unavailable(err: &str) -> String {
if is_chinese() {
format!("模型获取后台任务不可用: {err}")
} else {
format!("Model fetch worker unavailable: {err}")
}
}
pub fn tui_toast_model_fetch_worker_disabled() -> &'static str {
if is_chinese() {
"本次会话模型获取后台任务不可用。"
} else {
"Model fetch worker is disabled for this session."
}
}
pub fn tui_toast_webdav_worker_disabled() -> &'static str {
if is_chinese() {
"本次会话 WebDAV 后台任务不可用。"
} else {
"WebDAV worker is disabled for this session."
}
}
pub fn tui_error_skills_worker_unavailable() -> &'static str {
if is_chinese() {
"Skills 后台任务不可用。"
} else {
"Skills worker unavailable."
}
}
pub fn tui_toast_skills_discover_finished(count: usize) -> String {
if is_chinese() {
format!("发现完成：{count} 个结果。")
} else {
format!("Discover finished: {count} result(s).")
}
}
pub fn tui_toast_skills_discover_failed(err: &str) -> String {
if is_chinese() {
format!("发现失败: {err}")
} else {
format!("Discover failed: {err}")
}
}
pub fn tui_toast_skill_installed(directory: &str) -> String {
if is_chinese() {
format!("已安装: {directory}")
} else {
format!("Installed: {directory}")
}
}
pub fn tui_toast_skill_install_failed(spec: &str, err: &str) -> String {
if is_chinese() {
format!("安装失败（{spec}）: {err}")
} else {
format!("Install failed ({spec}): {err}")
}
}
pub fn tui_toast_skill_already_installed() -> &'static str {
if is_chinese() {
"该 Skill 已安装。"
} else {
"Skill already installed."
}
}
pub fn tui_toast_skill_spec_empty() -> &'static str {
if is_chinese() {
"Skill 不能为空。"
} else {
"Skill spec is empty."
}
}
pub fn tui_toast_skill_toggled(directory: &str, enabled: bool) -> String {
if is_chinese() {
format!("{} {directory}", if enabled { "已启用" } else { "已禁用" })
} else {
format!(
"{} {directory}",
if enabled { "Enabled" } else { "Disabled" }
)
}
}
pub fn tui_toast_skill_uninstalled(directory: &str) -> String {
if is_chinese() {
format!("已卸载: {directory}")
} else {
format!("Uninstalled: {directory}")
}
}
pub fn tui_toast_skill_apps_updated() -> &'static str {
if is_chinese() {
"Skill 应用已更新。"
} else {
"Skill apps updated."
}
}
pub fn tui_toast_skills_synced() -> &'static str {
if is_chinese() {
"Skills 同步完成。"
} else {
"Skills synced."
}
}
pub fn tui_toast_skills_sync_method_set(method: &str) -> String {
if is_chinese() {
format!("同步方式已设置为: {method}")
} else {
format!("Sync method set to: {method}")
}
}
pub fn tui_toast_repo_spec_empty() -> &'static str {
if is_chinese() {
"仓库不能为空。"
} else {
"Repository is empty."
}
}
pub fn tui_error_repo_spec_empty() -> &'static str {
if is_chinese() {
"仓库不能为空。"
} else {
"Repository cannot be empty."
}
}
pub fn tui_error_repo_spec_invalid() -> &'static str {
if is_chinese() {
"仓库格式无效。请使用 owner/name 或 https://github.com/owner/name"
} else {
"Invalid repo format. Use owner/name or https://github.com/owner/name"
}
}
pub fn tui_toast_repo_added() -> &'static str {
if is_chinese() {
"仓库已添加。"
} else {
"Repository added."
}
}
pub fn tui_toast_repo_removed() -> &'static str {
if is_chinese() {
"仓库已移除。"
} else {
"Repository removed."
}
}
pub fn tui_toast_repo_toggled(enabled: bool) -> String {
if is_chinese() {
if enabled {
"仓库已启用。".to_string()
} else {
"仓库已禁用。".to_string()
}
} else {
if enabled {
"Repository enabled.".to_string()
} else {
"Repository disabled.".to_string()
}
}
}
pub fn tui_toast_skip_claude_onboarding_toggled(enabled: bool) -> String {
if is_chinese() {
if enabled {
"已跳过 Claude Code 初次安装确认。".to_string()
} else {
"已恢复 Claude Code 初次安装确认。".to_string()
}
} else {
if enabled {
"Claude Code onboarding confirmation will be skipped.".to_string()
} else {
"Claude Code onboarding confirmation restored.".to_string()
}
}
}
pub fn tui_toast_claude_plugin_integration_toggled(enabled: bool) -> String {
if is_chinese() {
if enabled {
"已启用 Claude Code for VSCode 插件联动。".to_string()
} else {
"已关闭 Claude Code for VSCode 插件联动。".to_string()
}
} else {
if enabled {
"Claude Code for VSCode integration enabled.".to_string()
} else {
"Claude Code for VSCode integration disabled.".to_string()
}
}
}
pub fn tui_toast_claude_plugin_sync_failed(err: &str) -> String {
if is_chinese() {
format!("同步 Claude Code for VSCode 插件失败: {err}")
} else {
format!("Failed to sync Claude Code for VSCode integration: {err}")
}
}
pub fn tui_toast_unmanaged_scanned(count: usize) -> String {
if is_chinese() {
format!("扫描完成：发现 {count} 个可导入技能。")
} else {
format!("Scan finished: found {count} skill(s) available to import.")
}
}
pub fn tui_toast_no_unmanaged_selected() -> &'static str {
if is_chinese() {
"请至少选择一个要导入的技能。"
} else {
"Select at least one skill to import."
}
}
pub fn tui_toast_unmanaged_imported(count: usize) -> String {
if is_chinese() {
format!("已导入 {count} 个技能。")
} else {
format!("Imported {count} skill(s).")
}
}
pub fn tui_toast_provider_deleted() -> &'static str {
if is_chinese() {
"供应商已删除。"
} else {
"Provider deleted."
}
}
pub fn tui_toast_provider_add_finished() -> &'static str {
if is_chinese() {
"供应商新增流程已完成。"
} else {
"Provider add flow finished."
}
}
pub fn tui_toast_provider_add_missing_fields() -> &'static str {
if is_chinese() {
"请填写 name，id 会自动生成。"
} else {
"Please fill in name. id will be generated automatically."
}
}
pub fn tui_toast_provider_missing_name() -> &'static str {
if is_chinese() {
"请填写 name，id 会自动生成。"
} else {
"Please fill in name. id will be generated automatically."
}
}
pub fn tui_toast_provider_add_failed() -> &'static str {
if is_chinese() {
"新增供应商失败。"
} else {
"Failed to add provider."
}
}
pub fn tui_toast_provider_edit_finished() -> &'static str {
if is_chinese() {
"供应商编辑流程已完成。"
} else {
"Provider edit flow finished."
}
}
pub fn tui_toast_mcp_updated() -> &'static str {
if is_chinese() {
"MCP 已更新。"
} else {
"MCP updated."
}
}
pub fn tui_toast_mcp_upserted() -> &'static str {
if is_chinese() {
"MCP 服务器已保存。"
} else {
"MCP server saved."
}
}
pub fn tui_toast_mcp_missing_fields() -> &'static str {
if is_chinese() {
"请在 JSON 中填写 id 和 name。"
} else {
"Please fill in id and name in JSON."
}
}
pub fn tui_toast_mcp_server_deleted() -> &'static str {
if is_chinese() {
"MCP 服务器已删除。"
} else {
"MCP server deleted."
}
}
pub fn tui_toast_mcp_server_not_found() -> &'static str {
if is_chinese() {
"未找到 MCP 服务器。"
} else {
"MCP server not found."
}
}
pub fn tui_toast_mcp_imported(count: usize) -> String {
if is_chinese() {
format!("已导入 {count} 个 MCP 服务器。")
} else {
format!("Imported {count} MCP server(s).")
}
}
pub fn tui_toast_live_sync_skipped_uninitialized(app: &str) -> String {
if is_chinese() {
format!(
"未检测到 {app} 客户端本地配置，已跳过写入 live 文件；先运行一次 {app} 初始化后再试。"
)
} else {
format!("Live sync skipped: {app} client not initialized; run it once to initialize, then retry.")
}
}
pub fn tui_toast_mcp_updated_live_sync_skipped(apps: &[&str]) -> String {
let list = if is_chinese() {
apps.join("、")
} else {
apps.join(", ")
};
if is_chinese() {
format!(
"MCP 已更新，但以下客户端未初始化，已跳过写入 live 文件：{list}；先运行一次对应客户端初始化后再试。"
)
} else {
format!(
"MCP updated, but live sync skipped for uninitialized client(s): {list}; run them once to initialize, then retry."
)
}
}
pub fn tui_toast_prompt_activated() -> &'static str {
if is_chinese() {
"提示词已启用。"
} else {
"Prompt activated."
}
}
pub fn tui_toast_prompt_deactivated() -> &'static str {
if is_chinese() {
"提示词已停用。"
} else {
"Prompt deactivated."
}
}
pub fn tui_toast_prompt_deleted() -> &'static str {
if is_chinese() {
"提示词已删除。"
} else {
"Prompt deleted."
}
}
pub fn tui_toast_prompt_created() -> &'static str {
if is_chinese() {
"提示词已创建。"
} else {
"Prompt created."
}
}
pub fn tui_toast_prompt_renamed() -> &'static str {
if is_chinese() {
"提示词已重命名。"
} else {
"Prompt renamed."
}
}
pub fn tui_toast_exported_to(path: &str) -> String {
if is_chinese() {
format!("已导出到 {}", path)
} else {
format!("Exported to {}", path)
}
}
pub fn tui_error_import_file_not_found(path: &str) -> String {
if is_chinese() {
format!("导入文件不存在: {}", path)
} else {
format!("Import file not found: {}", path)
}
}
pub fn tui_toast_imported_config() -> &'static str {
if is_chinese() {
"配置已导入。"
} else {
"Imported config."
}
}
pub fn tui_toast_imported_with_backup(backup_id: &str) -> String {
if is_chinese() {
format!("已导入（备份: {backup_id}）")
} else {
format!("Imported (backup: {backup_id})")
}
}
pub fn tui_toast_no_config_file_to_backup() -> &'static str {
if is_chinese() {
"没有可备份的配置文件。"
} else {
"No config file to backup."
}
}
pub fn tui_toast_backup_created(id: &str) -> String {
if is_chinese() {
format!("备份已创建: {id}")
} else {
format!("Backup created: {id}")
}
}
pub fn tui_toast_restored_from_backup() -> &'static str {
if is_chinese() {
"已从备份恢复。"
} else {
"Restored from backup."
}
}
pub fn tui_toast_restored_with_pre_backup(pre_backup: &str) -> String {
if is_chinese() {
format!("已恢复（恢复前备份: {pre_backup}）")
} else {
format!("Restored (pre-backup: {pre_backup})")
}
}
pub fn tui_toast_webdav_settings_saved() -> &'static str {
if is_chinese() {
"WebDAV 同步设置已保存。"
} else {
"WebDAV sync settings saved."
}
}
pub fn tui_toast_proxy_takeover_requires_running() -> &'static str {
if is_chinese() {
"前台代理未运行，请先启动 `cc-switch proxy serve`。"
} else {
"Foreground proxy is not running. Start `cc-switch proxy serve` first."
}
}
pub fn tui_toast_proxy_takeover_updated(app: &str, enabled: bool) -> String {
if is_chinese() {
if enabled {
format!("已将 {app} 接管到前台代理。")
} else {
format!("已将 {app} 恢复到 live 配置。")
}
} else if enabled {
format!("{app} now uses the foreground proxy.")
} else {
format!("{app} restored to its live config.")
}
}
pub fn tui_toast_proxy_managed_current_app_updated(app: &str, enabled: bool) -> String {
if is_chinese() {
if enabled {
format!("{app} 已走 cc-switch 代理。")
} else {
format!("{app} 已恢复 live 配置。")
}
} else if enabled {
format!("{app} now routes through cc-switch.")
} else {
format!("{app} restored to its live config.")
}
}
pub fn tui_toast_proxy_worker_unavailable(err: &str) -> String {
if is_chinese() {
format!("代理任务不可用：{err}")
} else {
format!("Proxy worker unavailable: {err}")
}
}
pub fn tui_toast_proxy_request_failed(err: &str) -> String {
if is_chinese() {
format!("代理请求发送失败：{err}")
} else {
format!("Proxy request failed: {err}")
}
}
pub fn tui_error_proxy_worker_unavailable() -> &'static str {
if is_chinese() {
"代理任务不可用。"
} else {
"Proxy worker unavailable."
}
}
pub fn tui_toast_webdav_settings_cleared() -> &'static str {
if is_chinese() {
"WebDAV 同步设置已清空。"
} else {
"WebDAV sync settings cleared."
}
}
pub fn tui_toast_webdav_connection_ok() -> &'static str {
if is_chinese() {
"WebDAV 连接检查通过。"
} else {
"WebDAV connection check passed."
}
}
pub fn tui_toast_webdav_upload_ok() -> &'static str {
if is_chinese() {
"WebDAV 上传完成。"
} else {
"WebDAV upload completed."
}
}
pub fn tui_toast_webdav_download_ok() -> &'static str {
if is_chinese() {
"WebDAV 下载完成。"
} else {
"WebDAV download completed."
}
}
pub fn tui_webdav_v1_migration_title() -> &'static str {
if is_chinese() {
"发现旧版同步数据"
} else {
"Legacy sync data detected"
}
}
pub fn tui_webdav_v1_migration_message() -> &'static str {
if is_chinese() {
"远端存在 V1 格式的同步数据，是否迁移到 V2？\n迁移将下载旧数据、应用到本地、重新上传为新格式，并清理旧数据。"
} else {
"V1 sync data found on remote. Migrate to V2?\nThis will download old data, apply locally, re-upload as V2, and clean up V1 data."
}
}
pub fn tui_webdav_loading_title_v1_migration() -> &'static str {
if is_chinese() {
"V1 → V2 迁移"
} else {
"V1 → V2 Migration"
}
}
pub fn tui_toast_webdav_v1_migration_ok() -> &'static str {
if is_chinese() {
"V1 → V2 迁移完成，旧数据已清理。"
} else {
"V1 → V2 migration completed, old data cleaned up."
}
}
pub fn tui_toast_webdav_jianguoyun_configured() -> &'static str {
if is_chinese() {
"坚果云一键配置完成，连接检查通过。"
} else {
"Jianguoyun quick setup completed and connection verified."
}
}
pub fn tui_toast_webdav_username_empty() -> &'static str {
if is_chinese() {
"请输入 WebDAV 用户名。"
} else {
"Please enter a WebDAV username."
}
}
pub fn tui_toast_webdav_password_empty() -> &'static str {
if is_chinese() {
"请输入 WebDAV 第三方应用密码。"
} else {
"Please enter a WebDAV app password."
}
}
pub fn tui_toast_webdav_request_failed(err: &str) -> String {
if is_chinese() {
format!("WebDAV 请求提交失败: {err}")
} else {
format!("Failed to enqueue WebDAV request: {err}")
}
}
pub fn tui_toast_webdav_action_failed(action: &str, err: &str) -> String {
if is_chinese() {
format!("{action} 失败: {err}")
} else {
format!("{action} failed: {err}")
}
}
pub fn tui_toast_webdav_quick_setup_failed(err: &str) -> String {
if is_chinese() {
format!("坚果云一键配置已保存，但连接检查失败: {err}")
} else {
format!("Jianguoyun quick setup was saved, but connection check failed: {err}")
}
}
pub fn tui_toast_config_file_does_not_exist() -> &'static str {
if is_chinese() {
"配置文件不存在。"
} else {
"Config file does not exist."
}
}
pub fn tui_config_validation_title() -> &'static str {
if is_chinese() {
"配置校验"
} else {
"Config Validation"
}
}
pub fn tui_config_validation_failed_title() -> &'static str {
if is_chinese() {
"配置校验失败"
} else {
"Config Validation Failed"
}
}
pub fn tui_config_validation_ok() -> &'static str {
if is_chinese() {
"✓ 配置是有效的 JSON"
} else {
"✓ Configuration is valid JSON"
}
}
pub fn tui_config_validation_provider_count(app: &str, count: usize) -> String {
if is_chinese() {
format!("{app} 供应商: {count}")
} else {
format!("{app} providers: {count}")
}
}
pub fn tui_config_validation_mcp_servers(count: usize) -> String {
if is_chinese() {
format!("MCP 服务器: {count}")
} else {
format!("MCP servers: {count}")
}
}
pub fn tui_toast_validation_passed() -> &'static str {
if is_chinese() {
"校验通过。"
} else {
"Validation passed."
}
}
pub fn tui_toast_config_reset_to_defaults() -> &'static str {
if is_chinese() {
"配置已重置为默认值。"
} else {
"Config reset to defaults."
}
}
pub fn tui_toast_config_reset_with_backup(backup_id: &str) -> String {
if is_chinese() {
format!("配置已重置（备份: {backup_id}）")
} else {
format!("Config reset (backup: {backup_id})")
}
}
pub fn menu_home() -> &'static str {
let (en, zh) = menu_home_variants();
if is_chinese() {
zh
} else {
en
}
}
pub fn menu_home_variants() -> (&'static str, &'static str) {
("🏠 Home", "🏠 首页")
}
pub fn menu_manage_providers() -> &'static str {
let (en, zh) = menu_manage_providers_variants();
if is_chinese() {
zh
} else {
en
}
}
pub fn menu_manage_providers_variants() -> (&'static str, &'static str) {
("🔑 Providers", "🔑 供应商")
}
pub fn menu_manage_mcp() -> &'static str {
let (en, zh) = menu_manage_mcp_variants();
if is_chinese() {
zh
} else {
en
}
}
pub fn menu_manage_mcp_variants() -> (&'static str, &'static str) {
("🔌 MCP Servers", "🔌 MCP 服务器")
}
pub fn menu_manage_prompts() -> &'static str {
let (en, zh) = menu_manage_prompts_variants();
if is_chinese() {
zh
} else {
en
}
}
pub fn menu_manage_prompts_variants() -> (&'static str, &'static str) {
("💬 Prompts", "💬 提示词")
}
pub fn menu_manage_config() -> &'static str {
let (en, zh) = menu_manage_config_variants();
if is_chinese() {
zh
} else {
en
}
}
pub fn menu_manage_config_variants() -> (&'static str, &'static str) {
("📋 Configuration", "📋 配置")
}
pub fn menu_manage_skills() -> &'static str {
let (en, zh) = menu_manage_skills_variants();
if is_chinese() {
zh
} else {
en
}
}
pub fn menu_manage_skills_variants() -> (&'static str, &'static str) {
("🧩 Skills", "🧩 技能")
}
pub fn menu_openclaw_workspace() -> &'static str {
let (en, zh) = menu_openclaw_workspace_variants();
if is_chinese() {
zh
} else {
en
}
}
pub fn menu_openclaw_workspace_variants() -> (&'static str, &'static str) {
("📁 Workspace Files", "📁 Workspace 文件管理")
}
pub fn menu_openclaw_env() -> &'static str {
let (en, zh) = menu_openclaw_env_variants();
if is_chinese() {
zh
} else {
en
}
}
pub fn menu_openclaw_env_variants() -> (&'static str, &'static str) {
("🌱 Env Variables", "🌱 环境变量")
}
pub fn menu_openclaw_tools() -> &'static str {
let (en, zh) = menu_openclaw_tools_variants();
if is_chinese() {
zh
} else {
en
}
}
pub fn menu_openclaw_tools_variants() -> (&'static str, &'static str) {
("🔐 Tool Permissions", "🔐 工具权限")
}
pub fn menu_openclaw_agents() -> &'static str {
let (en, zh) = menu_openclaw_agents_variants();
if is_chinese() {
zh
} else {
en
}
}
pub fn menu_openclaw_agents_variants() -> (&'static str, &'static str) {
("🤖 Agents Config", "🤖 Agents 配置")
}
pub fn menu_settings() -> &'static str {
let (en, zh) = menu_settings_variants();
if is_chinese() {
zh
} else {
en
}
}
pub fn menu_settings_variants() -> (&'static str, &'static str) {
("🔧 Settings", "🔧 设置")
}
pub fn menu_exit() -> &'static str {
let (en, zh) = menu_exit_variants();
if is_chinese() {
zh
} else {
en
}
}
pub fn menu_exit_variants() -> (&'static str, &'static str) {
("🚪 Exit", "🚪 退出")
}
// ============================================
// SKILLS (Skills)
// ============================================
pub fn skills_management() -> &'static str {
if is_chinese() {
"技能管理"
} else {
"Skills Management"
}
}
pub fn no_skills_installed() -> &'static str {
if is_chinese() {
"未安装任何 Skills。"
} else {
"No skills installed."
}
}
pub fn skills_discover() -> &'static str {
if is_chinese() {
"🔎 发现/搜索 Skills"
} else {
"🔎 Discover/Search Skills"
}
}
pub fn skills_install() -> &'static str {
if is_chinese() {
"⬇️ 安装 Skill"
} else {
"⬇️ Install Skill"
}
}
pub fn skills_uninstall() -> &'static str {
if is_chinese() {
"🗑️ 卸载 Skill"
} else {
"🗑️ Uninstall Skill"
}
}
pub fn skills_toggle_for_app() -> &'static str {
if is_chinese() {
"✅ 启用/禁用（当前应用）"
} else {
"✅ Enable/Disable (Current App)"
}
}
pub fn skills_show_info() -> &'static str {
if is_chinese() {
"ℹ️ 查看 Skill 信息"
} else {
"ℹ️ Skill Info"
}
}
pub fn skills_sync_now() -> &'static str {
if is_chinese() {
"🔄 同步 Skills 到本地"
} else {
"🔄 Sync Skills to Live"
}
}
pub fn skills_sync_method() -> &'static str {
if is_chinese() {
"🔗 同步方式（auto/symlink/copy）"
} else {
"🔗 Sync Method (auto/symlink/copy)"
}
}
pub fn skills_select_sync_method() -> &'static str {
if is_chinese() {
"选择同步方式："
} else {
"Select sync method:"
}
}
pub fn skills_current_sync_method(method: &str) -> String {
if is_chinese() {
format!("当前同步方式：{method}")
} else {
format!("Current sync method: {method}")
}
}
pub fn skills_current_app_note(app: &str) -> String {
if is_chinese() {
format!("提示：启用/禁用将作用于当前应用（{app}）。")
} else {
format!("Note: Enable/Disable applies to the current app ({app}).")
}
}
pub fn skills_scan_unmanaged() -> &'static str {
if is_chinese() {
"🕵️ 查找已有技能"
} else {
"🕵️ Find Existing Skills"
}
}
pub fn skills_import_from_apps() -> &'static str {
if is_chinese() {
"📥 导入已有技能"
} else {
"📥 Import Existing Skills"
}
}
pub fn skills_manage_repos() -> &'static str {
if is_chinese() {
"📦 管理技能仓库"
} else {
"📦 Manage Skill Repos"
}
}
pub fn skills_enter_query() -> &'static str {
if is_chinese() {
"输入搜索关键词（可选）："
} else {
"Enter search query (optional):"
}
}
pub fn skills_enter_install_spec() -> &'static str {
if is_chinese() {
"输入技能目录，或完整标识（owner/name:directory）："
} else {
"Enter a skill directory, or a full key (owner/name:directory):"
}
}
pub fn skills_select_skill() -> &'static str {
if is_chinese() {
"选择一个 Skill："
} else {
"Select a skill:"
}
}
pub fn skills_confirm_install(name: &str, app: &str) -> String {
if is_chinese() {
format!("确认安装 '{name}' 并启用到 {app}？")
} else {
format!("Install '{name}' and enable for {app}?")
}
}
pub fn skills_confirm_uninstall(name: &str) -> String {
if is_chinese() {
format!("确认卸载 '{name}'？")
} else {
format!("Uninstall '{name}'?")
}
}
pub fn skills_confirm_toggle(name: &str, app: &str, enabled: bool) -> String {
if is_chinese() {
if enabled {
format!("确认启用 '{name}' 到 {app}？")
} else {
format!("确认在 {app} 禁用 '{name}'？")
}
} else if enabled {
format!("Enable '{name}' for {app}?")
} else {
format!("Disable '{name}' for {app}?")
}
}
pub fn skills_no_unmanaged_found() -> &'static str {
if is_chinese() {
"未发现可导入的技能。所有技能已在 CC Switch 中统一管理。"
} else {
"No skills to import found. All skills are already managed by CC Switch."
}
}
pub fn skills_select_unmanaged_to_import() -> &'static str {
if is_chinese() {
"选择要导入的技能："
} else {
"Select skills to import:"
}
}
pub fn skills_repos_management() -> &'static str {
if is_chinese() {
"技能仓库管理"
} else {
"Skill Repos"
}
}
pub fn skills_repo_list() -> &'static str {
if is_chinese() {
"📋 查看仓库列表"
} else {
"📋 List Repos"
}
}
pub fn skills_repo_add() -> &'static str {
if is_chinese() {
"➕ 添加仓库"
} else {
"➕ Add Repo"
}
}
pub fn skills_repo_remove() -> &'static str {
if is_chinese() {
"➖ 移除仓库"
} else {
"➖ Remove Repo"
}
}
pub fn skills_repo_enter_spec() -> &'static str {
if is_chinese() {
"输入 GitHub 仓库（owner/name，可选 @branch）或完整 URL："
} else {
"Enter a GitHub repository (owner/name, optional @branch) or a full URL:"
}
}
// ============================================
// PROVIDER MANAGEMENT (供应商管理)
// ============================================
pub fn provider_management() -> &'static str {
if is_chinese() {
"🔌 供应商管理"
} else {
"🔌 Provider Management"
}
}
pub fn no_providers() -> &'static str {
if is_chinese() {
"未找到供应商。"
} else {
"No providers found."
}
}
pub fn view_current_provider() -> &'static str {
if is_chinese() {
"📋 查看当前供应商详情"
} else {
"📋 View Current Provider Details"
}
}
pub fn switch_provider() -> &'static str {
if is_chinese() {
"🔄 切换供应商"
} else {
"🔄 Switch Provider"
}
}
pub fn add_provider() -> &'static str {
if is_chinese() {
"➕ 新增供应商"
} else {
"➕ Add Provider"
}
}
pub fn add_official_provider() -> &'static str {
if is_chinese() {
"添加官方供应商"
} else {
"Add Official Provider"
}
}
pub fn add_third_party_provider() -> &'static str {
if is_chinese() {
"添加第三方供应商"
} else {
"Add Third-Party Provider"
}
}
pub fn select_provider_add_mode() -> &'static str {
if is_chinese() {
"请选择供应商类型："
} else {
"Select provider type:"
}
}
pub fn delete_provider() -> &'static str {
if is_chinese() {
"🗑️ 删除供应商"
} else {
"🗑️ Delete Provider"
}
}
pub fn back_to_main() -> &'static str {
if is_chinese() {
"⬅️ 返回主菜单"
} else {
"⬅️ Back to Main Menu"
}
}
pub fn choose_action() -> &'static str {
if is_chinese() {
"选择操作："
} else {
"Choose an action:"
}
}
pub fn esc_to_go_back_help() -> &'static str {
if is_chinese() {
"Esc 返回上一步"
} else {
"Esc to go back"
}
}
pub fn select_filter_help() -> &'static str {
if is_chinese() {
"Esc 返回；输入可过滤"
} else {
"Esc to go back; type to filter"
}
}
pub fn current_provider_details() -> &'static str {
if is_chinese() {
"当前供应商详情"
} else {
"Current Provider Details"
}
}
pub fn only_one_provider() -> &'static str {
if is_chinese() {
"只有一个供应商，无法切换。"
} else {
"Only one provider available. Cannot switch."
}
}
pub fn no_other_providers() -> &'static str {
if is_chinese() {
"没有其他供应商可切换。"
} else {
"No other providers to switch to."
}
}
pub fn select_provider_to_switch() -> &'static str {
if is_chinese() {
"选择要切换到的供应商："
} else {
"Select provider to switch to:"
}
}
pub fn switched_to_provider(id: &str) -> String {
if is_chinese() {
format!("✓ 已切换到供应商 '{}'", id)
} else {
format!("✓ Switched to provider '{}'", id)
}
}
pub fn provider_added_to_app_config(id: &str, app: &str) -> String {
if is_chinese() {
format!("✓ 已将供应商 '{}' 添加到 {} 配置", id, app)
} else {
format!("✓ Added provider '{}' to {} config", id, app)
}
}
pub fn restart_note() -> &'static str {
if is_chinese() {
"注意：请重启 CLI 客户端以应用更改。"
} else {
"Note: Restart your CLI client to apply the changes."
}
}
pub fn live_sync_skipped_uninitialized_warning(app: &str) -> String {
if is_chinese() {
format!("⚠ 未检测到 {app} 客户端本地配置，已跳过写入 live 文件；先运行一次 {app} 初始化后再试。")
} else {
format!("⚠ Live sync skipped: {app} client not initialized; run it once to initialize, then retry.")
}
}
pub fn no_deletable_providers() -> &'static str {
if is_chinese() {
"没有可删除的供应商（无法删除当前供应商）。"
} else {
"No providers available for deletion (cannot delete current provider)."
}
}
pub fn select_provider_to_delete() -> &'static str {
if is_chinese() {
"选择要删除的供应商："
} else {
"Select provider to delete:"
}
}
pub fn confirm_delete(id: &str) -> String {
if is_chinese() {
format!("确定要删除供应商 '{}' 吗？", id)
} else {
format!("Are you sure you want to delete provider '{}'?", id)
}
}
pub fn cancelled() -> &'static str {
if is_chinese() {
"已取消。"
} else {
"Cancelled."
}
}
pub fn selection_cancelled() -> &'static str {
if is_chinese() {
"已取消选择"
} else {
"Selection cancelled"
}
}
pub fn invalid_selection() -> &'static str {
if is_chinese() {
"选择无效"
} else {
"Invalid selection"
}
}
pub fn available_backups() -> &'static str {
if is_chinese() {
"可用备份"
} else {
"Available Backups"
}
}
pub fn no_backups_found() -> &'static str {
if is_chinese() {
"未找到备份。"
} else {
"No backups found."
}
}
pub fn create_backup_first_hint() -> &'static str {
if is_chinese() {
"请先创建备份：cc-switch config backup"
} else {
"Create a backup first: cc-switch config backup"
}
}
pub fn found_backups(count: usize) -> String {
if is_chinese() {
format!("找到 {} 个备份：", count)
} else {
format!("Found {} backup(s):", count)
}
}
pub fn select_backup_to_restore() -> &'static str {
if is_chinese() {
"选择要恢复的备份："
} else {
"Select backup to restore:"
}
}
pub fn warning_title() -> &'static str {
if is_chinese() {
"警告："
} else {
"Warning:"
}
}
pub fn config_restore_warning_replace() -> &'static str {
if is_chinese() {
"这将用所选备份替换你当前的配置。"
} else {
"This will replace your current configuration with the selected backup."
}
}
pub fn config_restore_warning_pre_backup() -> &'static str {
if is_chinese() {
"系统会先创建一次当前状态的备份。"
} else {
"A backup of the current state will be created first."
}
}
pub fn config_restore_confirm_prompt() -> &'static str {
if is_chinese() {
"确认继续恢复？"
} else {
"Continue with restore?"
}
}
pub fn deleted_provider(id: &str) -> String {
if is_chinese() {
format!("✓ 已删除供应商 '{}'", id)
} else {
format!("✓ Deleted provider '{}'", id)
}
}
// Provider Input - Basic Fields
pub fn provider_name_label() -> &'static str {
if is_chinese() {
"供应商名称："
} else {
"Provider Name:"
}
}
pub fn provider_name_help() -> &'static str {
if is_chinese() {
"必填，用于显示的友好名称"
} else {
"Required, friendly display name"
}
}
pub fn provider_name_help_edit() -> &'static str {
if is_chinese() {
"必填，直接回车保持原值"
} else {
"Required, press Enter to keep"
}
}
pub fn provider_name_placeholder() -> &'static str {
"OpenAI"
}
pub fn provider_name_empty_error() -> &'static str {
if is_chinese() {
"供应商名称不能为空"
} else {
"Provider name cannot be empty"
}
}
pub fn website_url_label() -> &'static str {
if is_chinese() {
"官网 URL（可选）："
} else {
"Website URL (opt.):"
}
}
pub fn website_url_help() -> &'static str {
if is_chinese() {
"供应商的网站地址，直接回车跳过"
} else {
"Provider's website, press Enter to skip"
}
}
pub fn website_url_help_edit() -> &'static str {
if is_chinese() {
"留空则不修改，直接回车跳过"
} else {
"Leave blank to keep, Enter to skip"
}
}
pub fn website_url_placeholder() -> &'static str {
"https://openai.com"
}
// Provider Commands
pub fn no_providers_hint() -> &'static str {
"Use 'cc-switch provider add' to create a new provider."
}
pub fn app_config_not_found(app: &str) -> String {
if is_chinese() {
format!("应用 {} 配置不存在", app)
} else {
format!("Application {} configuration not found", app)
}
}
pub fn provider_not_found(id: &str) -> String {
if is_chinese() {
format!("供应商不存在: {}", id)
} else {
format!("Provider not found: {}", id)
}
}
pub fn generated_id(id: &str) -> String {
if is_chinese() {
format!("生成的 ID: {}", id)
} else {
format!("Generated ID: {}", id)
}
}
pub fn configure_optional_fields_prompt() -> &'static str {
if is_chinese() {
"配置可选字段（备注、排序索引）？"
} else {
"Configure optional fields (notes, sort index)?"
}
}
pub fn current_config_header() -> &'static str {
if is_chinese() {
"当前配置："
} else {
"Current Configuration:"
}
}
pub fn modify_provider_config_prompt() -> &'static str {
if is_chinese() {
"修改供应商配置（API Key, Base URL 等）？"
} else {
"Modify provider configuration (API Key, Base URL, etc.)?"
}
}
pub fn modify_optional_fields_prompt() -> &'static str {
if is_chinese() {
"修改可选字段（备注、排序索引）？"
} else {
"Modify optional fields (notes, sort index)?"
}
}
pub fn current_provider_synced_warning() -> &'static str {
if is_chinese() {
"⚠ 此供应商当前已激活，修改已同步到 live 配置"
} else {
"⚠ This provider is currently active, changes synced to live config"
}
}
pub fn input_failed_error(err: &str) -> String {
if is_chinese() {
format!("输入失败: {}", err)
} else {
format!("Input failed: {}", err)
}
}
pub fn cannot_delete_current_provider() -> &'static str {
"Cannot delete the current active provider. Please switch to another provider first."
}
// Provider Input - Basic Fields
pub fn provider_name_prompt() -> &'static str {
if is_chinese() {
"供应商名称："
} else {
"Provider Name:"
}
}
// Provider Input - Claude Configuration
pub fn config_claude_header() -> &'static str {
if is_chinese() {
"配置 Claude 供应商："
} else {
"Configure Claude Provider:"
}
}
pub fn api_key_label() -> &'static str {
if is_chinese() {
"API Key："
} else {
"API Key:"
}
}
pub fn api_key_help() -> &'static str {
if is_chinese() {
"留空使用默认值"
} else {
"Leave empty to use default"
}
}
pub fn base_url_label() -> &'static str {
if is_chinese() {
"Base URL："
} else {
"Base URL:"
}
}
pub fn base_url_empty_error() -> &'static str {
if is_chinese() {
"API 请求地址不能为空"
} else {
"API URL cannot be empty"
}
}
pub fn base_url_placeholder() -> &'static str {
if is_chinese() {
"如 https://api.anthropic.com"
} else {
"e.g., https://api.anthropic.com"
}
}
pub fn configure_model_names_prompt() -> &'static str {
if is_chinese() {
"配置模型名称？"
} else {
"Configure model names?"
}
}
pub fn model_default_label() -> &'static str {
if is_chinese() {
"默认模型："
} else {
"Default Model:"
}
}
pub fn model_default_help() -> &'static str {
if is_chinese() {
"留空使用 Claude Code 默认模型"
} else {
"Leave empty to use Claude Code default"
}
}
pub fn model_haiku_label() -> &'static str {
if is_chinese() {
"Haiku 模型："
} else {
"Haiku Model:"
}
}
pub fn model_haiku_placeholder() -> &'static str {
if is_chinese() {
"如 claude-3-5-haiku-20241022"
} else {
"e.g., claude-3-5-haiku-20241022"
}
}
pub fn model_sonnet_label() -> &'static str {
if is_chinese() {
"Sonnet 模型："
} else {
"Sonnet Model:"
}
}
pub fn model_sonnet_placeholder() -> &'static str {
if is_chinese() {
"如 claude-3-5-sonnet-20241022"
} else {
"e.g., claude-3-5-sonnet-20241022"
}
}
pub fn model_opus_label() -> &'static str {
if is_chinese() {
"Opus 模型："
} else {
"Opus Model:"
}
}
pub fn model_opus_placeholder() -> &'static str {
if is_chinese() {
"如 claude-3-opus-20240229"
} else {
"e.g., claude-3-opus-20240229"
}
}
// Provider Input - Codex Configuration
pub fn config_codex_header() -> &'static str {
if is_chinese() {
"配置 Codex 供应商："
} else {
"Configure Codex Provider:"
}
}
pub fn openai_api_key_label() -> &'static str {
if is_chinese() {
"OpenAI API Key："
} else {
"OpenAI API Key:"
}
}
pub fn anthropic_api_key_label() -> &'static str {
if is_chinese() {
"Anthropic API Key："
} else {
"Anthropic API Key:"
}
}
pub fn config_toml_label() -> &'static str {
if is_chinese() {
"配置内容 (TOML)："
} else {
"Config Content (TOML):"
}
}
pub fn config_toml_help() -> &'static str {
if is_chinese() {
"按 Esc 后 Enter 提交"
} else {
"Press Esc then Enter to submit"
}
}
pub fn config_toml_placeholder() -> &'static str {
if is_chinese() {
"留空使用默认配置"
} else {
"Leave empty to use default config"
}
}
// Codex 0.64+ Configuration
pub fn codex_auth_mode_info() -> &'static str {
if is_chinese() {
"⚠ 请选择 Codex 的鉴权方式（决定 API Key 从哪里读取）"
} else {
"⚠ Choose how Codex authenticates (where the API key is read from)"
}
}
pub fn codex_auth_mode_label() -> &'static str {
if is_chinese() {
"认证方式："
} else {
"Auth Mode:"
}
}
pub fn codex_auth_mode_help() -> &'static str {
if is_chinese() {
"OpenAI 认证：使用 auth.json/凭据存储；环境变量：使用 env_key 指定的变量（未设置会报错）"
} else {
"OpenAI auth uses auth.json/credential store; env var mode uses env_key (missing env var will error)"
}
}
pub fn codex_auth_mode_openai() -> &'static str {
if is_chinese() {
"OpenAI 认证（推荐，无需环境变量）"
} else {
"OpenAI auth (recommended, no env var)"
}
}
pub fn codex_auth_mode_env_var() -> &'static str {
if is_chinese() {
"环境变量（env_key，需要手动 export）"
} else {
"Environment variable (env_key, requires export)"
}
}
pub fn codex_official_provider_tip() -> &'static str {
if is_chinese() {
"提示：官方供应商将使用 Codex 官方登录保存的凭证（codex login 可能会打开浏览器），无需填写 API Key"
} else {
"Tip: Official provider uses Codex login credentials (`codex login` may open a browser); no API key required"
}
}
pub fn codex_env_key_info() -> &'static str {
if is_chinese() {
"⚠ 环境变量模式：Codex 将从指定的环境变量读取 API Key"
} else {
"⚠ Env var mode: Codex will read the API key from the specified environment variable"
}
}
pub fn codex_env_key_label() -> &'static str {
if is_chinese() {
"环境变量名称："
} else {
"Environment Variable Name:"
}
}
pub fn codex_env_key_help() -> &'static str {
if is_chinese() {
"Codex 将从此环境变量读取 API 密钥（默认: OPENAI_API_KEY）"
} else {
"Codex will read API key from this env var (default: OPENAI_API_KEY)"
}
}
pub fn codex_wire_api_label() -> &'static str {
if is_chinese() {
"API 格式："
} else {
"API Format:"
}
}
pub fn codex_wire_api_help() -> &'static str {
if is_chinese() {
"chat = Chat Completions API (大多数第三方), responses = OpenAI Responses API"
} else {
"chat = Chat Completions API (most providers), responses = OpenAI Responses API"
}
}
pub fn codex_env_reminder(env_key: &str) -> String {
if is_chinese() {
format!(
"⚠ 请确保已设置环境变量 {} 并包含您的 API 密钥\n 例如: export {}=\"your-api-key\"",
env_key, env_key
)
} else {
format!(
"⚠ Make sure to set the {} environment variable with your API key\n Example: export {}=\"your-api-key\"",
env_key, env_key
)
}
}
pub fn codex_openai_auth_info() -> &'static str {
if is_chinese() {
"✓ OpenAI 认证模式：Codex 将使用 auth.json/系统凭据存储，无需设置 OPENAI_API_KEY 环境变量"
} else {
"✓ OpenAI auth mode: Codex will use auth.json/credential store; no OPENAI_API_KEY env var required"
}
}
pub fn codex_dual_write_info(env_key: &str, _api_key: &str) -> String {
if is_chinese() {
format!(
"✓ 双写模式已启用（兼容所有 Codex 版本）\n\
• 旧版本 Codex: 将使用 auth.json 中的 API Key\n\
• Codex 0.64+: 可使用环境变量 {} (更安全)\n\
例如: export {}=\"your-api-key\"",
env_key, env_key
)
} else {
format!(
"✓ Dual-write mode enabled (compatible with all Codex versions)\n\
• Legacy Codex: Will use API Key from auth.json\n\
• Codex 0.64+: Can use env variable {} (more secure)\n\
Example: export {}=\"your-api-key\"",
env_key, env_key
)
}
}
pub fn use_current_config_prompt() -> &'static str {
if is_chinese() {
"使用当前配置？"
} else {
"Use current configuration?"
}
}
pub fn use_current_config_help() -> &'static str {
if is_chinese() {
"选择 No 将进入自定义输入模式"
} else {
"Select No to enter custom input mode"
}
}
pub fn input_toml_config() -> &'static str {
if is_chinese() {
"输入 TOML 配置（多行，输入空行结束）："
} else {
"Enter TOML config (multiple lines, empty line to finish):"
}
}
pub fn direct_enter_to_finish() -> &'static str {
if is_chinese() {
"直接回车结束输入"
} else {
"Press Enter to finish"
}
}
pub fn current_config_label() -> &'static str {
if is_chinese() {
"当前配置："
} else {
"Current Config:"
}
}
pub fn config_toml_header() -> &'static str {
if is_chinese() {
"Config.toml 配置："
} else {
"Config.toml Configuration:"
}
}
// Provider Input - Gemini Configuration
pub fn config_gemini_header() -> &'static str {
if is_chinese() {
"配置 Gemini 供应商："
} else {
"Configure Gemini Provider:"
}
}
pub fn auth_type_label() -> &'static str {
if is_chinese() {
"认证类型："
} else {
"Auth Type:"
}
}
pub fn auth_type_api_key() -> &'static str {
if is_chinese() {
"API Key"
} else {
"API Key"
}
}
pub fn auth_type_service_account() -> &'static str {
if is_chinese() {
"Service Account (ADC)"
} else {
"Service Account (ADC)"
}
}
pub fn gemini_api_key_label() -> &'static str {
if is_chinese() {
"Gemini API Key："
} else {
"Gemini API Key:"
}
}
pub fn gemini_base_url_label() -> &'static str {
if is_chinese() {
"Base URL："
} else {
"Base URL:"
}
}
pub fn gemini_base_url_help() -> &'static str {
if is_chinese() {
"留空使用官方 API"
} else {
"Leave empty to use official API"
}
}
pub fn gemini_base_url_placeholder() -> &'static str {
if is_chinese() {
"如 https://generativelanguage.googleapis.com"
} else {
"e.g., https://generativelanguage.googleapis.com"
}
}
pub fn adc_project_id_label() -> &'static str {
if is_chinese() {
"GCP Project ID："
} else {
"GCP Project ID:"
}
}
pub fn adc_location_label() -> &'static str {
if is_chinese() {
"GCP Location："
} else {
"GCP Location:"
}
}
pub fn adc_location_placeholder() -> &'static str {
if is_chinese() {
"如 us-central1"
} else {
"e.g., us-central1"
}
}
pub fn google_oauth_official() -> &'static str {
if is_chinese() {
"Google OAuth（官方）"
} else {
"Google OAuth (Official)"
}
}
pub fn packycode_api_key() -> &'static str {
if is_chinese() {
"PackyCode API Key"
} else {
"PackyCode API Key"
}
}
pub fn generic_api_key() -> &'static str {
if is_chinese() {
"通用 API Key"
} else {
"Generic API Key"
}
}
pub fn select_auth_method_help() -> &'static str {
if is_chinese() {
"选择 Gemini 的认证方式"
} else {
"Select authentication method for Gemini"
}
}
pub fn use_google_oauth_warning() -> &'static str {
if is_chinese() {
"使用 Google OAuth，将清空 API Key 配置"
} else {
"Using Google OAuth, API Key config will be cleared"
}
}
pub fn packycode_api_key_help() -> &'static str {
if is_chinese() {
"从 PackyCode 获取的 API Key"
} else {
"API Key obtained from PackyCode"
}
}
pub fn packycode_endpoint_help() -> &'static str {
if is_chinese() {
"PackyCode API 端点"
} else {
"PackyCode API endpoint"
}
}
pub fn generic_api_key_help() -> &'static str {
if is_chinese() {
"通用的 Gemini API Key"
} else {
"Generic Gemini API Key"
}
}
// Provider Input - Optional Fields
pub fn notes_label() -> &'static str {
if is_chinese() {
"备注："
} else {
"Notes:"
}
}
pub fn notes_placeholder() -> &'static str {
if is_chinese() {
"可选的备注信息"
} else {
"Optional notes"
}
}
pub fn sort_index_label() -> &'static str {
if is_chinese() {
"排序索引："
} else {
"Sort Index:"
}
}
pub fn sort_index_help() -> &'static str {
if is_chinese() {
"数字越小越靠前，留空使用创建时间排序"
} else {
"Lower numbers appear first, leave empty to sort by creation time"
}
}
pub fn sort_index_placeholder() -> &'static str {
if is_chinese() {
"如 1, 2, 3..."
} else {
"e.g., 1, 2, 3..."
}
}
pub fn invalid_sort_index() -> &'static str {
if is_chinese() {
"排序索引必须是有效的数字"
} else {
"Sort index must be a valid number"
}
}
pub fn optional_fields_config() -> &'static str {
if is_chinese() {
"可选字段配置："
} else {
"Optional Fields Configuration:"
}
}
pub fn notes_example_placeholder() -> &'static str {
if is_chinese() {
"自定义供应商，用于测试"
} else {
"Custom provider for testing"
}
}
pub fn notes_help_edit() -> &'static str {
if is_chinese() {
"关于此供应商的额外说明，直接回车保持原值"
} else {
"Additional notes about this provider, press Enter to keep current value"
}
}
pub fn notes_help_new() -> &'static str {
if is_chinese() {
"关于此供应商的额外说明，直接回车跳过"
} else {
"Additional notes about this provider, press Enter to skip"
}
}
pub fn sort_index_help_edit() -> &'static str {
if is_chinese() {
"数字，用于控制显示顺序，直接回车保持原值"
} else {
"Number for display order, press Enter to keep current value"
}
}
pub fn sort_index_help_new() -> &'static str {
if is_chinese() {
"数字，用于控制显示顺序，直接回车跳过"
} else {
"Number for display order, press Enter to skip"
}
}
pub fn invalid_sort_index_number() -> &'static str {
if is_chinese() {
"排序索引必须是数字"
} else {
"Sort index must be a number"
}
}
pub fn provider_config_summary() -> &'static str {
if is_chinese() {
"=== 供应商配置摘要 ==="
} else {
"=== Provider Configuration Summary ==="
}
}
pub fn id_label() -> &'static str {
if is_chinese() {
"ID"
} else {
"ID"
}
}
pub fn website_label() -> &'static str {
if is_chinese() {
"官网"
} else {
"Website"
}
}
pub fn core_config_label() -> &'static str {
if is_chinese() {
"核心配置："
} else {
"Core Configuration:"
}
}
pub fn model_label() -> &'static str {
if is_chinese() {
"模型"
} else {
"Model"
}
}
pub fn config_toml_lines(count: usize) -> String {
if is_chinese() {
format!("Config (TOML): {} 行", count)
} else {
format!("Config (TOML): {} lines", count)
}
}
pub fn optional_fields_label() -> &'static str {
if is_chinese() {
"可选字段："
} else {
"Optional Fields:"
}
}
pub fn notes_label_colon() -> &'static str {
if is_chinese() {
"备注"
} else {
"Notes"
}
}
pub fn sort_index_label_colon() -> &'static str {
if is_chinese() {
"排序索引"
} else {
"Sort Index"
}
}
pub fn id_label_colon() -> &'static str {
if is_chinese() {
"ID"
} else {
"ID"
}
}
pub fn url_label_colon() -> &'static str {
if is_chinese() {
"网址"
} else {
"URL"
}
}
pub fn api_url_label_colon() -> &'static str {
if is_chinese() {
"API 地址"
} else {
"API URL"
}
}
pub fn summary_divider() -> &'static str {
"======================"
}
// Provider Input - Summary Display
pub fn basic_info_header() -> &'static str {
if is_chinese() {
"基本信息"
} else {
"Basic Info"
}
}
pub fn name_display_label() -> &'static str {
if is_chinese() {
"名称"
} else {
"Name"
}
}
pub fn app_display_label() -> &'static str {
if is_chinese() {
"应用"
} else {
"App"
}
}
pub fn notes_display_label() -> &'static str {
if is_chinese() {
"备注"
} else {
"Notes"
}
}
pub fn sort_index_display_label() -> &'static str {
if is_chinese() {
"排序"
} else {
"Sort Index"
}
}
pub fn config_info_header() -> &'static str {
if is_chinese() {
"配置信息"
} else {
"Configuration"
}
}
pub fn api_key_display_label() -> &'static str {
if is_chinese() {
"API Key"
} else {
"API Key"
}
}
pub fn base_url_display_label() -> &'static str {
if is_chinese() {
"Base URL"
} else {
"Base URL"
}
}
pub fn model_config_header() -> &'static str {
if is_chinese() {
"模型配置"
} else {
"Model Configuration"
}
}
pub fn default_model_display() -> &'static str {
if is_chinese() {
"默认"
} else {
"Default"
}
}
pub fn haiku_model_display() -> &'static str {
if is_chinese() {
"Haiku"
} else {
"Haiku"
}
}
pub fn sonnet_model_display() -> &'static str {
if is_chinese() {
"Sonnet"
} else {
"Sonnet"
}
}
pub fn opus_model_display() -> &'static str {
if is_chinese() {
"Opus"
} else {
"Opus"
}
}
pub fn auth_type_display_label() -> &'static str {
if is_chinese() {
"认证"
} else {
"Auth Type"
}
}
pub fn project_id_display_label() -> &'static str {
if is_chinese() {
"项目 ID"
} else {
"Project ID"
}
}
pub fn location_display_label() -> &'static str {
if is_chinese() {
"位置"
} else {
"Location"
}
}
// Interactive Provider - Menu Options
pub fn edit_provider_menu() -> &'static str {
if is_chinese() {
"➕ 编辑供应商"
} else {
"➕ Edit Provider"
}
}
pub fn no_editable_providers() -> &'static str {
if is_chinese() {
"没有可编辑的供应商"
} else {
"No providers available for editing"
}
}
pub fn select_provider_to_edit() -> &'static str {
if is_chinese() {
"选择要编辑的供应商："
} else {
"Select provider to edit:"
}
}
pub fn choose_edit_mode() -> &'static str {
if is_chinese() {
"选择编辑模式："
} else {
"Choose edit mode:"
}
}
pub fn select_config_file_to_edit() -> &'static str {
if is_chinese() {
"选择要编辑的配置文件："
} else {
"Select config file to edit:"
}
}
pub fn provider_missing_auth_field() -> &'static str {
if is_chinese() {
"settings_config 中缺少 'auth' 字段"
} else {
"Missing 'auth' field in settings_config"
}
}
pub fn provider_missing_or_invalid_config_field() -> &'static str {
if is_chinese() {
"settings_config 中缺少或无效的 'config' 字段"
} else {
"Missing or invalid 'config' field in settings_config"
}
}
pub fn edit_mode_interactive() -> &'static str {
if is_chinese() {
"📝 交互式编辑 (分步提示)"
} else {
"📝 Interactive editing (step-by-step prompts)"
}
}
pub fn edit_mode_json_editor() -> &'static str {
if is_chinese() {
"✏️ JSON 编辑 (使用外部编辑器)"
} else {
"✏️ JSON editing (use external editor)"
}
}
pub fn cancel() -> &'static str {
if is_chinese() {
"❌ 取消"
} else {
"❌ Cancel"
}
}
pub fn opening_external_editor() -> &'static str {
if is_chinese() {
"正在打开外部编辑器..."
} else {
"Opening external editor..."
}
}
pub fn invalid_json_syntax() -> &'static str {
if is_chinese() {
"无效的 JSON 语法"
} else {
"Invalid JSON syntax"
}
}
pub fn invalid_provider_structure() -> &'static str {
if is_chinese() {
"无效的供应商结构"
} else {
"Invalid provider structure"
}
}
pub fn provider_id_cannot_be_changed() -> &'static str {
if is_chinese() {
"供应商 ID 不能被修改"
} else {
"Provider ID cannot be changed"
}
}
pub fn retry_editing() -> &'static str {
if is_chinese() {
"是否重新编辑？"
} else {
"Retry editing?"
}
}
pub fn no_changes_detected() -> &'static str {
if is_chinese() {
"未检测到任何更改"
} else {
"No changes detected"
}
}
pub fn provider_summary() -> &'static str {
if is_chinese() {
"供应商信息摘要"
} else {
"Provider Summary"
}
}
pub fn confirm_save_changes() -> &'static str {
if is_chinese() {
"确认保存更改？"
} else {
"Save changes?"
}
}
pub fn editor_failed() -> &'static str {
if is_chinese() {
"编辑器失败"
} else {
"Editor failed"
}
}
pub fn invalid_selection_format() -> &'static str {
if is_chinese() {
"无效的选择格式"
} else {
"Invalid selection format"
}
}
// Provider Display Labels (for show_current and view_provider_detail)
pub fn basic_info_section_header() -> &'static str {
if is_chinese() {
"基本信息 / Basic Info"
} else {
"Basic Info"
}
}
pub fn name_label_with_colon() -> &'static str {
if is_chinese() {
"名称"
} else {
"Name"
}
}
pub fn app_label_with_colon() -> &'static str {
if is_chinese() {
"应用"
} else {
"App"
}
}
pub fn api_config_section_header() -> &'static str {
if is_chinese() {
"API 配置 / API Configuration"
} else {
"API Configuration"
}
}
pub fn model_config_section_header() -> &'static str {
if is_chinese() {
"模型配置 / Model Configuration"
} else {
"Model Configuration"
}
}
pub fn main_model_label_with_colon() -> &'static str {
if is_chinese() {
"主模型"
} else {
"Main Model"
}
}
pub fn updated_config_header() -> &'static str {
if is_chinese() {
"修改后配置："
} else {
"Updated Configuration:"
}
}
// Provider Add/Edit Messages
pub fn generated_id_message(id: &str) -> String {
if is_chinese() {
format!("生成的 ID: {}", id)
} else {
format!("Generated ID: {}", id)
}
}
pub fn edit_fields_instruction() -> &'static str {
if is_chinese() {
"逐个编辑字段（直接回车保留当前值）：\n"
} else {
"Edit fields one by one (press Enter to keep current value):\n"
}
}
// ============================================
// MCP SERVER MANAGEMENT (MCP 服务器管理)
// ============================================
pub fn mcp_management() -> &'static str {
if is_chinese() {
"🛠️ MCP 服务器管理"
} else {
"🛠️ MCP Server Management"
}
}
pub fn no_mcp_servers() -> &'static str {
if is_chinese() {
"未找到 MCP 服务器。"
} else {
"No MCP servers found."
}
}
pub fn sync_all_servers() -> &'static str {
if is_chinese() {
"🔄 同步所有服务器"
} else {
"🔄 Sync All Servers"
}
}
pub fn synced_successfully() -> &'static str {
if is_chinese() {
"✓ 所有 MCP 服务器同步成功"
} else {
"✓ All MCP servers synced successfully"
}
}
// ============================================
// PROMPT MANAGEMENT (提示词管理)
// ============================================
pub fn prompts_management() -> &'static str {
if is_chinese() {
"💬 提示词管理"
} else {
"💬 Prompt Management"
}
}
pub fn no_prompts() -> &'static str {
if is_chinese() {
"未找到提示词预设。"
} else {
"No prompt presets found."
}
}
pub fn switch_active_prompt() -> &'static str {
if is_chinese() {
"🔄 切换活动提示词"
} else {
"🔄 Switch Active Prompt"
}
}
pub fn no_prompts_available() -> &'static str {
if is_chinese() {
"没有可用的提示词。"
} else {
"No prompts available."
}
}
pub fn select_prompt_to_activate() -> &'static str {
if is_chinese() {
"选择要激活的提示词："
} else {
"Select prompt to activate:"
}
}
pub fn activated_prompt(id: &str) -> String {
if is_chinese() {
format!("✓ 已激活提示词 '{}'", id)
} else {
format!("✓ Activated prompt '{}'", id)
}
}
pub fn deactivated_prompt(id: &str) -> String {
if is_chinese() {
format!("✓ 已取消激活提示词 '{}'", id)
} else {
format!("✓ Deactivated prompt '{}'", id)
}
}
pub fn prompt_cleared_note() -> &'static str {
if is_chinese() {
"实时文件已清空"
} else {
"Live prompt file has been cleared"
}
}
pub fn prompt_synced_note() -> &'static str {
if is_chinese() {
"注意：提示词已同步到实时配置文件。"
} else {
"Note: The prompt has been synced to the live configuration file."
}
}
// Configuration View
pub fn current_configuration() -> &'static str {
if is_chinese() {
"👁️ 当前配置"
} else {
"👁️ Current Configuration"
}
}
pub fn provider_label() -> &'static str {
if is_chinese() {
"供应商："
} else {
"Provider:"
}
}
pub fn mcp_servers_label() -> &'static str {
if is_chinese() {
"MCP 服务器："
} else {
"MCP Servers:"
}
}
pub fn tui_label_mcp_short() -> &'static str {
"MCP:"
}
pub fn tui_label_skills() -> &'static str {
if is_chinese() {
"技能:"
} else {
"Skills:"
}
}
pub fn prompts_label() -> &'static str {
if is_chinese() {
"提示词："
} else {
"Prompts:"
}
}
pub fn total() -> &'static str {
if is_chinese() {
"总计"
} else {
"Total"
}
}
pub fn enabled() -> &'static str {
if is_chinese() {
"启用"
} else {
"Enabled"
}
}
pub fn disabled() -> &'static str {
if is_chinese() {
"禁用"
} else {
"Disabled"
}
}
pub fn active() -> &'static str {
if is_chinese() {
"活动"
} else {
"Active"
}
}
pub fn none() -> &'static str {
if is_chinese() {
"无"
} else {
"None"
}
}
// Settings
pub fn settings_title() -> &'static str {
if is_chinese() {
"⚙️ 设置"
} else {
"⚙️ Settings"
}
}
pub fn change_language() -> &'static str {
if is_chinese() {
"🌐 切换语言"
} else {
"🌐 Change Language"
}
}
pub fn current_language_label() -> &'static str {
if is_chinese() {
"当前语言"
} else {
"Current Language"
}
}
pub fn select_language() -> &'static str {
if is_chinese() {
"选择语言："
} else {
"Select language:"
}
}
pub fn language_changed() -> &'static str {
if is_chinese() {
"✓ 语言已更改"
} else {
"✓ Language changed"
}
}
pub fn skip_claude_onboarding() -> &'static str {
if is_chinese() {
"🚫 跳过 Claude Code 初次安装确认"
} else {
"🚫 Skip Claude Code onboarding confirmation"
}
}
pub fn skip_claude_onboarding_label() -> &'static str {
if is_chinese() {
"跳过 Claude Code 初次安装确认"
} else {
"Skip Claude Code onboarding confirmation"
}
}
pub fn skip_claude_onboarding_confirm(enable: bool, path: &str) -> String {
if is_chinese() {
if enable {
format!(
"确认启用跳过 Claude Code 初次安装确认？\n将写入 {path}: hasCompletedOnboarding=true"
)
} else {
format!(
"确认恢复 Claude Code 初次安装确认？\n将从 {path} 删除 hasCompletedOnboarding"
)
}
} else {
if enable {
format!(
"Enable skipping Claude Code onboarding confirmation?\nWrites hasCompletedOnboarding=true to {path}"
)
} else {
format!(
"Disable skipping Claude Code onboarding confirmation?\nRemoves hasCompletedOnboarding from {path}"
)
}
}
}
pub fn skip_claude_onboarding_changed(enable: bool) -> String {
if is_chinese() {
if enable {
"✓ 已启用：跳过 Claude Code 初次安装确认".to_string()
} else {
"✓ 已恢复 Claude Code 初次安装确认".to_string()
}
} else {
if enable {
"✓ Skip Claude Code onboarding confirmation enabled".to_string()
} else {
"✓ Claude Code onboarding confirmation restored".to_string()
}
}
}
pub fn enable_claude_plugin_integration() -> &'static str {
if is_chinese() {
"🔌 接管 Claude Code for VSCode 插件"
} else {
"🔌 Apply to Claude Code for VSCode"
}
}
pub fn enable_claude_plugin_integration_label() -> &'static str {
if is_chinese() {
"接管 Claude Code for VSCode 插件"
} else {
"Apply to Claude Code for VSCode"
}
}
pub fn enable_claude_plugin_integration_confirm(enable: bool, path: &str) -> String {
if is_chinese() {
if enable {
format!(
"确认启用 Claude Code for VSCode 插件联动？\n将写入 {path}: primaryApiKey=\"any\""
)
} else {
"确认关闭 Claude Code for VSCode 插件联动？".to_string()
}
} else {
if enable {
format!(
"Enable Claude Code for VSCode integration?\nWrites primaryApiKey=\"any\" to {path}"
)
} else {
format!(
"Disable Claude Code for VSCode integration?\nRemoves primaryApiKey from {path}"
)
}
}
}
pub fn enable_claude_plugin_integration_changed(enable: bool) -> String {
if is_chinese() {
if enable {
"✓ 已启用 Claude Code for VSCode 插件联动".to_string()
} else {
"✓ 已关闭 Claude Code for VSCode 插件联动".to_string()
}
} else {
if enable {
"✓ Claude Code for VSCode integration enabled".to_string()
} else {
"✓ Claude Code for VSCode integration disabled".to_string()
}
}
}
pub fn claude_plugin_sync_failed_warning(err: &str) -> String {
if is_chinese() {
format!("⚠ Claude Code for VSCode 插件联动失败: {err}")
} else {
format!("⚠ Claude Code for VSCode integration failed: {err}")
}
}
// App Selection
pub fn select_application() -> &'static str {
if is_chinese() {
"选择应用程序："
} else {
"Select application:"
}
}
pub fn switched_to_app(app: &str) -> String {
if is_chinese() {
format!("✓ 已切换到 {}", app)
} else {
format!("✓ Switched to {}", app)
}
}
// Common
pub fn press_enter() -> &'static str {
if is_chinese() {
"按 Enter 继续..."
} else {
"Press Enter to continue..."
}
}
pub fn error_prefix() -> &'static str {
if is_chinese() {
"错误"
} else {
"Error"
}
}
// Table Headers
pub fn header_name() -> &'static str {
if is_chinese() {
"名称"
} else {
"Name"
}
}
pub fn header_category() -> &'static str {
if is_chinese() {
"类别"
} else {
"Category"
}
}
pub fn header_description() -> &'static str {
if is_chinese() {
"描述"
} else {
"Description"
}
}
// Config Management
pub fn config_management() -> &'static str {
if is_chinese() {
"⚙️ 配置文件管理"
} else {
"⚙️ Configuration Management"
}
}
pub fn config_export() -> &'static str {
if is_chinese() {
"📤 导出配置"
} else {
"📤 Export Config"
}
}
pub fn config_import() -> &'static str {
if is_chinese() {
"📥 导入配置"
} else {
"📥 Import Config"
}
}
pub fn config_backup() -> &'static str {
if is_chinese() {
"💾 备份配置"
} else {
"💾 Backup Config"
}
}
pub fn config_restore() -> &'static str {
if is_chinese() {
"♻️ 恢复配置"
} else {
"♻️ Restore Config"
}
}
pub fn config_validate() -> &'static str {
if is_chinese() {
"✓ 验证配置"
} else {
"✓ Validate Config"
}
}
pub fn config_common_snippet() -> &'static str {
if is_chinese() {
"🧩 通用配置片段"
} else {
"🧩 Common Config Snippet"
}
}
pub fn config_common_snippet_title() -> &'static str {
if is_chinese() {
"通用配置片段"
} else {
"Common Config Snippet"
}
}
pub fn config_common_snippet_none_set() -> &'static str {
if is_chinese() {
"未设置通用配置片段。"
} else {
"No common config snippet is set."
}
}
pub fn config_common_snippet_set_for_app(app: &str) -> String {
if is_chinese() {
format!("✓ 已为应用 '{}' 设置通用配置片段", app)
} else {
format!("✓ Common config snippet set for app '{}'", app)
}
}
pub fn config_common_snippet_require_json_or_file() -> &'static str {
if is_chinese() {
"请提供 --json 或 --file"
} else {
"Please provide --json or --file"
}
}
pub fn config_reset() -> &'static str {
if is_chinese() {
"🔄 重置配置"
} else {
"🔄 Reset Config"
}
}
pub fn config_show_full() -> &'static str {
if is_chinese() {
"👁️ 查看完整配置"
} else {
"👁️ Show Full Config"
}
}
pub fn config_show_path() -> &'static str {
if is_chinese() {
"📍 显示配置路径"
} else {
"📍 Show Config Path"
}
}
pub fn enter_export_path() -> &'static str {
if is_chinese() {
"输入导出文件路径："
} else {
"Enter export file path:"
}
}
pub fn enter_import_path() -> &'static str {
if is_chinese() {
"输入导入文件路径："
} else {
"Enter import file path:"
}
}
pub fn enter_restore_path() -> &'static str {
if is_chinese() {
"输入备份文件路径："
} else {
"Enter backup file path:"
}
}
pub fn confirm_import() -> &'static str {
if is_chinese() {
"确定要导入配置吗？这将覆盖当前配置。"
} else {
"Are you sure you want to import? This will overwrite current configuration."
}
}
pub fn confirm_reset() -> &'static str {
if is_chinese() {
"确定要重置配置吗？这将删除所有自定义设置。"
} else {
"Are you sure you want to reset? This will delete all custom settings."
}
}
pub fn common_config_snippet_editor_prompt(app: &str) -> String {
let is_codex = app == "codex";
if is_chinese() {
if is_codex {
format!("编辑 {app} 的通用配置片段（TOML，留空则清除）：")
} else {
format!("编辑 {app} 的通用配置片段（JSON 对象，留空则清除）：")
}
} else {
if is_codex {
format!("Edit common config snippet for {app} (TOML; empty to clear):")
} else {
format!("Edit common config snippet for {app} (JSON object; empty to clear):")
}
}
}
pub fn common_config_snippet_invalid_json(err: &str) -> String {
if is_chinese() {
format!("JSON 无效：{err}")
} else {
format!("Invalid JSON: {err}")
}
}
pub fn common_config_snippet_invalid_toml(err: &str) -> String {
if is_chinese() {
format!("TOML 无效：{err}")
} else {
format!("Invalid TOML: {err}")
}
}
pub fn failed_to_serialize_json(err: &str) -> String {
if is_chinese() {
format!("序列化 JSON 失败：{err}")
} else {
format!("Failed to serialize JSON: {err}")
}
}
pub fn common_config_snippet_not_object() -> &'static str {
if is_chinese() {
"通用配置必须是 JSON 对象（例如：{\"env\":{...}}）"
} else {
"Common config must be a JSON object (e.g. {\"env\":{...}})"
}
}
pub fn common_config_snippet_saved() -> &'static str {
if is_chinese() {
"✓ 已保存通用配置片段"
} else {
"✓ Common config snippet saved"
}
}
pub fn common_config_snippet_cleared() -> &'static str {
if is_chinese() {
"✓ 已清除通用配置片段"
} else {
"✓ Common config snippet cleared"
}
}
pub fn common_config_snippet_apply_now() -> &'static str {
if is_chinese() {
"现在应用到当前供应商（写入 live 配置）？"
} else {
"Apply to current provider now (write live config)?"
}
}
pub fn common_config_snippet_no_current_provider() -> &'static str {
if is_chinese() {
"当前未选择供应商，已保存通用配置片段。"
} else {
"No current provider selected; common config snippet saved."
}
}
pub fn common_config_snippet_no_current_provider_after_clear() -> &'static str {
if is_chinese() {
"当前未选择供应商，已清除通用配置片段。"
} else {
"No current provider selected; common config snippet cleared."
}
}
pub fn common_config_snippet_applied() -> &'static str {
if is_chinese() {
"✓ 已在适用时刷新 live 配置（请重启对应客户端）"
} else {
"✓ Refreshed live config when applicable (restart the client)"
}
}
pub fn common_config_snippet_apply_hint() -> &'static str {
if is_chinese() {
"提示：切换一次供应商即可重新写入 live 配置。"
} else {
"Tip: switch provider once to re-write the live config."
}
}
pub fn common_config_snippet_apply_not_needed() -> &'static str {
if is_chinese() {
"当前配置已是最新，无需重新应用。"
} else {
"The current live config is already up to date; nothing to apply."
}
}
pub fn confirm_restore() -> &'static str {
if is_chinese() {
"确定要从备份恢复配置吗？"
} else {
"Are you sure you want to restore from backup?"
}
}
pub fn exported_to(path: &str) -> String {
if is_chinese() {
format!("✓ 已导出到 '{}'", path)
} else {
format!("✓ Exported to '{}'", path)
}
}
pub fn imported_from(path: &str) -> String {
if is_chinese() {
format!("✓ 已从 '{}' 导入", path)
} else {
format!("✓ Imported from '{}'", path)
}
}
pub fn backup_created(id: &str) -> String {
if is_chinese() {
format!("✓ 已创建备份，ID: {}", id)
} else {
format!("✓ Backup created, ID: {}", id)
}
}
pub fn restored_from(path: &str) -> String {
if is_chinese() {
format!("✓ 已从 '{}' 恢复", path)
} else {
format!("✓ Restored from '{}'", path)
}
}
pub fn config_valid() -> &'static str {
if is_chinese() {
"✓ 配置文件有效"
} else {
"✓ Configuration is valid"
}
}
pub fn config_reset_done() -> &'static str {
if is_chinese() {
"✓ 配置已重置为默认值"
} else {
"✓ Configuration reset to defaults"
}
}
pub fn file_overwrite_confirm(path: &str) -> String {
if is_chinese() {
format!("文件 '{}' 已存在，是否覆盖？", path)
} else {
format!("File '{}' exists. Overwrite?", path)
}
}
// MCP Management Additional
pub fn mcp_delete_server() -> &'static str {
if is_chinese() {
"🗑️ 删除服务器"
} else {
"🗑️ Delete Server"
}
}
pub fn mcp_enable_server() -> &'static str {
if is_chinese() {
"✅ 启用服务器"
} else {
"✅ Enable Server"
}
}
pub fn mcp_disable_server() -> &'static str {
if is_chinese() {
"❌ 禁用服务器"
} else {
"❌ Disable Server"
}
}
pub fn mcp_import_servers() -> &'static str {
if is_chinese() {
"📥 导入已有 MCP 服务器"
} else {
"📥 Import Existing MCP Servers"
}
}
pub fn mcp_validate_command() -> &'static str {
if is_chinese() {
"✓ 验证命令"
} else {
"✓ Validate Command"
}
}
pub fn select_server_to_delete() -> &'static str {
if is_chinese() {
"选择要删除的服务器："
} else {
"Select server to delete:"
}
}
pub fn select_server_to_enable() -> &'static str {
if is_chinese() {
"选择要启用的服务器："
} else {
"Select server to enable:"
}
}
pub fn select_server_to_disable() -> &'static str {
if is_chinese() {
"选择要禁用的服务器："
} else {
"Select server to disable:"
}
}
pub fn select_apps_to_enable() -> &'static str {
if is_chinese() {
"选择要启用的应用："
} else {
"Select apps to enable for:"
}
}
pub fn select_apps_to_disable() -> &'static str {
if is_chinese() {
"选择要禁用的应用："
} else {
"Select apps to disable for:"
}
}
pub fn enter_command_to_validate() -> &'static str {
if is_chinese() {
"输入要验证的命令："
} else {
"Enter command to validate:"
}
}
pub fn server_deleted(id: &str) -> String {
if is_chinese() {
format!("✓ 已删除服务器 '{}'", id)
} else {
format!("✓ Deleted server '{}'", id)
}
}
pub fn server_enabled(id: &str) -> String {
if is_chinese() {
format!("✓ 已启用服务器 '{}'", id)
} else {
format!("✓ Enabled server '{}'", id)
}
}
pub fn server_disabled(id: &str) -> String {
if is_chinese() {
format!("✓ 已禁用服务器 '{}'", id)
} else {
format!("✓ Disabled server '{}'", id)
}
}
pub fn servers_imported(count: usize) -> String {
if is_chinese() {
format!("✓ 已导入 {count} 个 MCP 服务器")
} else {
format!("✓ Imported {count} MCP server(s)")
}
}
pub fn command_valid(cmd: &str) -> String {
if is_chinese() {
format!("✓ 命令 '{}' 有效", cmd)
} else {
format!("✓ Command '{}' is valid", cmd)
}
}
pub fn command_invalid(cmd: &str) -> String {
if is_chinese() {
format!("✗ 命令 '{}' 未找到", cmd)
} else {
format!("✗ Command '{}' not found", cmd)
}
}
// Prompts Management Additional
pub fn prompts_show_content() -> &'static str {
if is_chinese() {
"👁️ 查看完整内容"
} else {
"👁️ View Full Content"
}
}
pub fn prompts_delete() -> &'static str {
if is_chinese() {
"🗑️ 删除提示词"
} else {
"🗑️ Delete Prompt"
}
}
pub fn prompts_view_current() -> &'static str {
if is_chinese() {
"📋 查看当前提示词"
} else {
"📋 View Current Prompt"
}
}
pub fn select_prompt_to_view() -> &'static str {
if is_chinese() {
"选择要查看的提示词："
} else {
"Select prompt to view:"
}
}
pub fn select_prompt_to_delete() -> &'static str {
if is_chinese() {
"选择要删除的提示词："
} else {
"Select prompt to delete:"
}
}
pub fn prompt_deleted(id: &str) -> String {
if is_chinese() {
format!("✓ 已删除提示词 '{}'", id)
} else {
format!("✓ Deleted prompt '{}'", id)
}
}
pub fn no_active_prompt() -> &'static str {
if is_chinese() {
"当前没有激活的提示词。"
} else {
"No active prompt."
}
}
pub fn cannot_delete_active() -> &'static str {
if is_chinese() {
"无法删除当前激活的提示词。"
} else {
"Cannot delete the active prompt."
}
}
pub fn no_servers_to_delete() -> &'static str {
if is_chinese() {
"没有可删除的服务器。"
} else {
"No servers to delete."
}
}
pub fn no_prompts_to_delete() -> &'static str {
if is_chinese() {
"没有可删除的提示词。"
} else {
"No prompts to delete."
}
}
// Provider Speedtest
pub fn speedtest_endpoint() -> &'static str {
if is_chinese() {
"🚀 测试端点速度"
} else {
"🚀 Speedtest endpoint"
}
}
pub fn back() -> &'static str {
if is_chinese() {
"← 返回"
} else {
"← Back"
}
}
// ============================================
// TUI UPDATE (TUI 自更新)
// ============================================
pub fn tui_settings_check_for_updates() -> &'static str {
if is_chinese() {
"检查更新"
} else {
"Check for Updates"
}
}
pub fn tui_update_checking_title() -> &'static str {
if is_chinese() {
"检查更新中"
} else {
"Checking for Updates"
}
}
pub fn tui_update_available_title() -> &'static str {
if is_chinese() {
"发现新版本"
} else {
"Update Available"
}
}
pub fn tui_update_downloading_title() -> &'static str {
if is_chinese() {
"正在更新"
} else {
"Updating"
}
}
pub fn tui_update_result_title() -> &'static str {
if is_chinese() {
"更新结果"
} else {
"Update Result"
}
}
pub fn tui_update_version_info(current: &str, new: &str) -> String {
if is_chinese() {
format!("当前: v{current} → 最新: {new}")
} else {
format!("Current: v{current} → Latest: {new}")
}
}
pub fn tui_update_btn_update() -> &'static str {
if is_chinese() {
"更新"
} else {
"Update"
}
}
pub fn tui_update_btn_cancel() -> &'static str {
if is_chinese() {
"取消"
} else {
"Cancel"
}
}
pub fn tui_update_downloading_kb(kb: u64) -> String {
if is_chinese() {
format!("已下载 {kb} KB")
} else {
format!("Downloaded {kb} KB")
}
}
pub fn tui_update_downloading_progress(pct: u64, downloaded_kb: u64, total_kb: u64) -> String {
if is_chinese() {
format!("{pct}% ({downloaded_kb} / {total_kb} KB)")
} else {
format!("{pct}% ({downloaded_kb} / {total_kb} KB)")
}
}
pub fn tui_update_success(tag: &str) -> String {
if is_chinese() {
format!("已更新到 {tag}，按 Enter 退出")
} else {
format!("Updated to {tag}. Press Enter to exit.")
}
}
pub fn tui_update_err_worker_unavailable() -> &'static str {
if is_chinese() {
"更新服务不可用"
} else {
"Update worker unavailable"
}
}
pub fn tui_update_err_check_first() -> &'static str {
if is_chinese() {
"请先检查更新"
} else {
"Please check for updates first"
}
}
pub fn tui_toast_already_latest(v: &str) -> String {
if is_chinese() {
format!("已是最新版本 v{v}")
} else {
format!("Already on latest v{v}")
}
}
pub fn tui_toast_update_downgrade(current: &str, target: &str) -> String {
if is_chinese() {
format!("当前 v{current} 比 {target} 更新")
} else {
format!("Current v{current} is newer than {target}")
}
}
pub fn tui_toast_update_check_failed(err: &str) -> String {
if is_chinese() {
format!("检查更新失败: {err}")
} else {
format!("Update check failed: {err}")
}
}
pub fn tui_key_hide() -> &'static str {
if is_chinese() {
"隐藏"
} else {
"hide"
}
}
pub fn tui_toast_update_bg_success(tag: &str) -> String {
if is_chinese() {
format!("后台更新到 {tag} 完成")
} else {
format!("Background update to {tag} complete")
}
}
pub fn tui_toast_update_bg_failed(err: &str) -> String {
if is_chinese() {
format!("后台更新失败: {err}")
} else {
format!("Background update failed: {err}")
}
}
pub fn tui_toast_provider_live_config_imported() -> &'static str {
if is_chinese() {
"已将当前 live 配置导入为供应商"
} else {
"Imported the current live config as a provider"
}
}
pub fn tui_toast_codex_live_config_imported() -> &'static str {
if is_chinese() {
"已将当前 Codex live 配置导入为供应商"
} else {
"Imported the current Codex live config as a provider"
}
}
pub fn tui_toast_no_live_config_imported() -> &'static str {
if is_chinese() {
"没有可导入的 live 供应商"
} else {
"No live providers were imported"
}
}
}
#[cfg(test)]
mod tests {
use super::{texts, use_test_language, Language};
use std::sync::mpsc;
use std::thread;
#[test]
fn website_url_label_keeps_optional_with_abbrev() {
let label = texts::website_url_label();
assert_eq!(label, "Website URL (opt.):");
assert!(label.contains("(opt.)"));
assert!(!label.contains("(optional)"));
}
#[test]
fn chinese_tui_copy_avoids_key_mixed_english_labels() {
let _lang = use_test_language(Language::Chinese);
assert_eq!(texts::tui_home_section_connection(), "连接信息");
assert_eq!(texts::tui_home_status_online(), "在线");
assert_eq!(texts::tui_home_status_offline(), "离线");
assert_eq!(texts::tui_label_mcp_servers_active(), "已启用");
assert_eq!(texts::skills_management(), "技能管理");
assert_eq!(texts::menu_manage_mcp(), "🔌 MCP 服务器");
let help = texts::tui_help_text();
assert!(help.contains("供应商：Enter 详情"));
assert!(help.contains("供应商详情：s 切换/添加移除"));
assert!(help.contains("提示词：c 新建，r 刷新，Enter 查看"));
assert!(help.contains("技能：Enter 详情"));
assert!(help.contains("配置：Enter 打开/执行"));
assert!(help.contains("设置：Enter 应用"));
assert!(!help.contains("Providers:"));
assert!(!help.contains("Provider Detail:"));
assert!(!help.contains("Skills:"));
assert!(!help.contains("Config:"));
assert!(!help.contains("Settings:"));
}
#[test]
fn proxy_dashboard_copy_is_fully_localized_in_chinese() {
let _lang = use_test_language(Language::Chinese);
assert_eq!(texts::tui_home_section_connection(), "连接信息");
assert_eq!(
texts::tui_proxy_dashboard_failover_copy(),
"仅做手动路由，不会自动切换供应商。"
);
assert_eq!(
texts::tui_proxy_dashboard_manual_routing_copy("Claude"),
"手动路由：Claude 的流量会通过 cc-switch。"
);
}
#[test]
fn openclaw_provider_status_copy_is_fully_localized_in_chinese() {
let _lang = use_test_language(Language::Chinese);
assert_eq!(texts::tui_label_openclaw_status(), "状态");
assert_eq!(texts::tui_label_openclaw_model(), "模型");
assert_eq!(texts::tui_openclaw_status_default(), "默认");
assert_eq!(
texts::tui_openclaw_status_in_config_and_saved(),
"配置中 + 已保存"
);
assert_eq!(texts::tui_openclaw_status_live_only(), "仅当前配置");
assert_eq!(texts::tui_openclaw_status_saved_only(), "仅已保存");
assert_eq!(texts::tui_openclaw_status_untracked(), "未跟踪");
}
#[test]
fn test_language_override_does_not_leak_across_threads() {
let _lang = use_test_language(Language::English);
let (ready_tx, ready_rx) = mpsc::channel();
let (release_tx, release_rx) = mpsc::channel();
let handle = thread::spawn(move || {
let _lang = use_test_language(Language::Chinese);
ready_tx.send(()).expect("signal ready");
release_rx.recv().expect("wait for release");
});
ready_rx.recv().expect("wait for child language override");
assert_eq!(
texts::tui_home_section_connection(),
"Connection Details",
"child thread language override should not affect this test thread"
);
release_tx.send(()).expect("release child thread");
handle.join().expect("join child thread");
}
}