refactor(backend): extract config and speedtest services (phase 4)

This commit continues the backend refactoring initiative by extracting
configuration management and API speedtest logic into dedicated service
layers, completing phase 4 of the architectural improvement plan.

## Changes

### New Service Layers
- **ConfigService** (`services/config.rs`): Consolidates all config
  import/export, backup management, and live sync operations
  - `create_backup()`: Creates timestamped backups with auto-cleanup
  - `export_config_to_path()`: Exports config to specified path
  - `load_config_for_import()`: Loads and validates imported config
  - `import_config_from_path()`: Full import with state update
  - `sync_current_providers_to_live()`: Syncs current providers to live files
  - Private helpers for Claude/Codex-specific sync logic

- **SpeedtestService** (`services/speedtest.rs`): Encapsulates endpoint
  latency testing with proper validation and error handling
  - `test_endpoints()`: Tests multiple URLs concurrently
  - URL validation now unified in service layer
  - Includes 3 unit tests for edge cases (empty list, invalid URLs, timeout clamping)

### Command Layer Refactoring
- Move all import/export commands to `commands/import_export.rs`
- Commands become thin wrappers: parse params → call service → return JSON
- Maintain `spawn_blocking` for I/O operations (phase 5 optimization)
- Lock acquisition happens after I/O completes (minimize contention)

### File Organization
- Delete: `import_export.rs`, `speedtest.rs` (root-level modules)
- Create: `commands/import_export.rs`, `services/config.rs`, `services/speedtest.rs`
- Update: Module declarations in `lib.rs`, `commands/mod.rs`, `services/mod.rs`

### Test Updates
- Update 20 integration tests in `import_export_sync.rs` to use `ConfigService` APIs
- All existing test cases pass without modification to test logic
- Add 3 new unit tests for `SpeedtestService`:
  - `sanitize_timeout_clamps_values`: Boundary value testing
  - `test_endpoints_handles_empty_list`: Empty input handling
  - `test_endpoints_reports_invalid_url`: Invalid URL error reporting

## Benefits

1. **Improved Testability**: Service methods are `pub fn`, easily callable
   from tests without Tauri runtime
2. **Better Separation of Concerns**: Business logic isolated from
   command/transport layer
3. **Enhanced Maintainability**: Related operations grouped in cohesive
   service structs
4. **Consistent Error Handling**: Services return `Result<T, AppError>`,
   commands convert to `Result<T, String>`
5. **Performance**: I/O operations run in `spawn_blocking`, locks released
   before file operations

## Testing

- ✅ All 43 tests passing (7 unit + 36 integration)
- ✅ `cargo fmt --check` passes
- ✅ `cargo clippy -- -D warnings` passes (zero warnings)

## Documentation

Updated `BACKEND_REFACTOR_PLAN.md` to reflect completion of config and
speedtest service extraction, marking phase 4 substantially complete.

Co-authored-by: Claude Code <code@anthropic.com>

src-tauri/src/commands/import_export.rs

@@ -0,0 +1,104 @@
+#![allow(non_snake_case)]
+
+use serde_json::{json, Value};
+use std::path::PathBuf;
+use tauri::State;
+use tauri_plugin_dialog::DialogExt;
+
+use crate::error::AppError;
+use crate::services::ConfigService;
+use crate::store::AppState;
+
+/// 导出配置文件
+#[tauri::command]
+pub async fn export_config_to_file(file_path: String) -> Result<Value, String> {
+    tauri::async_runtime::spawn_blocking(move || {
+        let target_path = PathBuf::from(&file_path);
+        ConfigService::export_config_to_path(&target_path)?;
+        Ok::<_, AppError>(json!({
+            "success": true,
+            "message": "Configuration exported successfully",
+            "filePath": file_path
+        }))
+    })
+    .await
+    .map_err(|e| format!("导出配置失败: {}", e))?
+    .map_err(|e: AppError| e.to_string())
+}
+
+/// 从文件导入配置
+#[tauri::command]
+pub async fn import_config_from_file(
+    file_path: String,
+    state: State<'_, AppState>,
+) -> Result<Value, String> {
+    let (new_config, backup_id) = tauri::async_runtime::spawn_blocking(move || {
+        let path_buf = PathBuf::from(&file_path);
+        ConfigService::load_config_for_import(&path_buf)
+    })
+    .await
+    .map_err(|e| format!("导入配置失败: {}", e))?
+    .map_err(|e: AppError| e.to_string())?;
+
+    {
+        let mut guard = state
+            .config
+            .write()
+            .map_err(|e| AppError::from(e).to_string())?;
+        *guard = new_config;
+    }
+
+    Ok(json!({
+        "success": true,
+        "message": "Configuration imported successfully",
+        "backupId": backup_id
+    }))
+}
+
+/// 同步当前供应商配置到对应的 live 文件
+#[tauri::command]
+pub async fn sync_current_providers_live(state: State<'_, AppState>) -> Result<Value, String> {
+    {
+        let mut config_state = state
+            .config
+            .write()
+            .map_err(|e| AppError::from(e).to_string())?;
+        ConfigService::sync_current_providers_to_live(&mut config_state)
+            .map_err(|e| e.to_string())?;
+    }
+
+    Ok(json!({
+        "success": true,
+        "message": "Live configuration synchronized"
+    }))
+}
+
+/// 保存文件对话框
+#[tauri::command]
+pub async fn save_file_dialog<R: tauri::Runtime>(
+    app: tauri::AppHandle<R>,
+    default_name: String,
+) -> Result<Option<String>, String> {
+    let dialog = app.dialog();
+    let result = dialog
+        .file()
+        .add_filter("JSON", &["json"])
+        .set_file_name(&default_name)
+        .blocking_save_file();
+
+    Ok(result.map(|p| p.to_string()))
+}
+
+/// 打开文件对话框
+#[tauri::command]
+pub async fn open_file_dialog<R: tauri::Runtime>(
+    app: tauri::AppHandle<R>,
+) -> Result<Option<String>, String> {
+    let dialog = app.dialog();
+    let result = dialog
+        .file()
+        .add_filter("JSON", &["json"])
+        .blocking_pick_file();
+
+    Ok(result.map(|p| p.to_string()))
+}

src-tauri/src/commands/mod.rs

@@ -1,6 +1,7 @@
 #![allow(non_snake_case)]
 
 mod config;
+mod import_export;
 mod mcp;
 mod misc;
 mod plugin;
@@ -8,6 +9,7 @@ mod provider;
 mod settings;
 
 pub use config::*;
+pub use import_export::*;
 pub use mcp::*;
 pub use misc::*;
 pub use plugin::*;

src-tauri/src/commands/provider.rs

@@ -10,8 +10,7 @@ use crate::codex_config;
 use crate::config::get_claude_settings_path;
 use crate::error::AppError;
 use crate::provider::{Provider, ProviderMeta};
-use crate::services::ProviderService;
-use crate::speedtest;
+use crate::services::{EndpointLatency, ProviderService, SpeedtestService};
 use crate::store::AppState;
 
 fn validate_provider_settings(app_type: &AppType, provider: &Provider) -> Result<(), String> {
@@ -572,12 +571,8 @@ pub async fn read_live_provider_settings(
 pub async fn test_api_endpoints(
     urls: Vec<String>,
     timeout_secs: Option<u64>,
-) -> Result<Vec<speedtest::EndpointLatency>, String> {
-    let filtered: Vec<String> = urls
-        .into_iter()
-        .filter(|url| !url.trim().is_empty())
-        .collect();
-    speedtest::test_endpoints(filtered, timeout_secs)
+) -> Result<Vec<EndpointLatency>, String> {
+    SpeedtestService::test_endpoints(urls, timeout_secs)
         .await
         .map_err(|e| e.to_string())
 }