refactor: migrate all Tauri commands to camelCase parameters

This commit addresses parameter naming inconsistencies caused by Tauri v2's
requirement for camelCase parameter names in IPC commands.

Backend changes (Rust):
- Updated all command parameters from snake_case to camelCase
- Commands affected:
  * provider.rs: providerId (×4), timeoutSecs
  * import_export.rs: filePath (×2), defaultName
  * config.rs: defaultPath
- Added #[allow(non_snake_case)] attributes for camelCase parameters
- Removed unused QueryUsageParams struct

Frontend changes (TypeScript):
- Removed redundant snake_case parameters from all invoke() calls
- Updated API files:
  * usage.ts: removed debug logs, unified to providerId
  * vscode.ts: updated 8 functions (providerId, timeoutSecs, filePath, defaultName)
  * settings.ts: updated 4 functions (defaultPath, filePath, defaultName)
- Ensured all parameters now use camelCase exclusively

Test updates:
- Updated MSW handlers to accept both old and new parameter formats during transition
- Added i18n mock compatibility for tests

Root cause:
The issue stemmed from Tauri v2 strictly requiring camelCase for command
parameters, while the codebase was using snake_case. This caused parameters
like 'provider_id' to not be recognized by the backend, resulting in
"missing providerId parameter" errors.

BREAKING CHANGE: All Tauri command invocations now require camelCase parameters.
Any external tools or scripts calling these commands must be updated accordingly.

Fixes: Usage query always failing with "missing providerId" error
Fixes: Custom endpoint management not receiving provider ID
Fixes: Import/export dialogs not respecting default paths

src-tauri/src/commands/config.rs

@@ -73,9 +73,10 @@ pub async fn open_config_folder(handle: AppHandle, app: String) -> Result<bool,
 #[tauri::command]
 pub async fn pick_directory(
     app: AppHandle,
-    default_path: Option<String>,
+    #[allow(non_snake_case)]
+    defaultPath: Option<String>,
 ) -> Result<Option<String>, String> {
-    let initial = default_path
+    let initial = defaultPath
         .map(|p| p.trim().to_string())
         .filter(|p| !p.is_empty());
 

src-tauri/src/commands/import_export.rs

@@ -11,14 +11,17 @@ use crate::store::AppState;
 
 /// 导出配置文件
 #[tauri::command]
-pub async fn export_config_to_file(file_path: String) -> Result<Value, String> {
+pub async fn export_config_to_file(
+    #[allow(non_snake_case)]
+    filePath: String
+) -> Result<Value, String> {
     tauri::async_runtime::spawn_blocking(move || {
-        let target_path = PathBuf::from(&file_path);
+        let target_path = PathBuf::from(&filePath);
         ConfigService::export_config_to_path(&target_path)?;
         Ok::<_, AppError>(json!({
             "success": true,
             "message": "Configuration exported successfully",
-            "filePath": file_path
+            "filePath": filePath
         }))
     })
     .await
@@ -29,11 +32,12 @@ pub async fn export_config_to_file(file_path: String) -> Result<Value, String> {
 /// 从文件导入配置
 #[tauri::command]
 pub async fn import_config_from_file(
-    file_path: String,
+    #[allow(non_snake_case)]
+    filePath: 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);
+        let path_buf = PathBuf::from(&filePath);
         ConfigService::load_config_for_import(&path_buf)
     })
     .await
@@ -77,13 +81,14 @@ pub async fn sync_current_providers_live(state: State<'_, AppState>) -> Result<V
 #[tauri::command]
 pub async fn save_file_dialog<R: tauri::Runtime>(
     app: tauri::AppHandle<R>,
-    default_name: String,
+    #[allow(non_snake_case)]
+    defaultName: String,
 ) -> Result<Option<String>, String> {
     let dialog = app.dialog();
     let result = dialog
         .file()
         .add_filter("JSON", &["json"])
-        .set_file_name(&default_name)
+        .set_file_name(&defaultName)
         .blocking_save_file();
 
     Ok(result.map(|p| p.to_string()))

src-tauri/src/commands/provider.rs

@@ -116,12 +116,12 @@ pub fn import_default_config(state: State<'_, AppState>, app: String) -> Result<
 #[tauri::command]
 pub async fn query_provider_usage(
     state: State<'_, AppState>,
-    provider_id: Option<String>,
+    #[allow(non_snake_case)]
+    providerId: String,  // 使用 camelCase 匹配前端
     app: String,
 ) -> Result<crate::provider::UsageResult, String> {
-    let provider_id = provider_id.ok_or_else(|| missing_param("providerId"))?;
     let app_type = AppType::from_str(&app).map_err(|e| e.to_string())?;
-    ProviderService::query_usage(state.inner(), app_type, &provider_id)
+    ProviderService::query_usage(state.inner(), app_type, &providerId)
         .await
         .map_err(|e| e.to_string())
 }
@@ -137,9 +137,10 @@ pub fn read_live_provider_settings(app: String) -> Result<serde_json::Value, Str
 #[tauri::command]
 pub async fn test_api_endpoints(
     urls: Vec<String>,
-    timeout_secs: Option<u64>,
+    #[allow(non_snake_case)]
+    timeoutSecs: Option<u64>,
 ) -> Result<Vec<EndpointLatency>, String> {
-    SpeedtestService::test_endpoints(urls, timeout_secs)
+    SpeedtestService::test_endpoints(urls, timeoutSecs)
         .await
         .map_err(|e| e.to_string())
 }
@@ -149,11 +150,11 @@ pub async fn test_api_endpoints(
 pub fn get_custom_endpoints(
     state: State<'_, AppState>,
     app: String,
-    provider_id: Option<String>,
+    #[allow(non_snake_case)]
+    providerId: String,
 ) -> Result<Vec<crate::settings::CustomEndpoint>, String> {
     let app_type = AppType::from_str(&app).map_err(|e| e.to_string())?;
-    let provider_id = provider_id.ok_or_else(|| missing_param("providerId"))?;
-    ProviderService::get_custom_endpoints(state.inner(), app_type, &provider_id)
+    ProviderService::get_custom_endpoints(state.inner(), app_type, &providerId)
         .map_err(|e| e.to_string())
 }
 
@@ -162,12 +163,12 @@ pub fn get_custom_endpoints(
 pub fn add_custom_endpoint(
     state: State<'_, AppState>,
     app: String,
-    provider_id: Option<String>,
+    #[allow(non_snake_case)]
+    providerId: String,
     url: String,
 ) -> Result<(), String> {
     let app_type = AppType::from_str(&app).map_err(|e| e.to_string())?;
-    let provider_id = provider_id.ok_or_else(|| missing_param("providerId"))?;
-    ProviderService::add_custom_endpoint(state.inner(), app_type, &provider_id, url)
+    ProviderService::add_custom_endpoint(state.inner(), app_type, &providerId, url)
         .map_err(|e| e.to_string())
 }
 
@@ -176,12 +177,12 @@ pub fn add_custom_endpoint(
 pub fn remove_custom_endpoint(
     state: State<'_, AppState>,
     app: String,
-    provider_id: Option<String>,
+    #[allow(non_snake_case)]
+    providerId: String,
     url: String,
 ) -> Result<(), String> {
     let app_type = AppType::from_str(&app).map_err(|e| e.to_string())?;
-    let provider_id = provider_id.ok_or_else(|| missing_param("providerId"))?;
-    ProviderService::remove_custom_endpoint(state.inner(), app_type, &provider_id, url)
+    ProviderService::remove_custom_endpoint(state.inner(), app_type, &providerId, url)
         .map_err(|e| e.to_string())
 }
 
@@ -190,12 +191,12 @@ pub fn remove_custom_endpoint(
 pub fn update_endpoint_last_used(
     state: State<'_, AppState>,
     app: String,
-    provider_id: Option<String>,
+    #[allow(non_snake_case)]
+    providerId: String,
     url: String,
 ) -> Result<(), String> {
     let app_type = AppType::from_str(&app).map_err(|e| e.to_string())?;
-    let provider_id = provider_id.ok_or_else(|| missing_param("providerId"))?;
-    ProviderService::update_endpoint_last_used(state.inner(), app_type, &provider_id, url)
+    ProviderService::update_endpoint_last_used(state.inner(), app_type, &providerId, url)
         .map_err(|e| e.to_string())
 }