feat：移除了弹窗，服务器添加sls

apps/app/src/api/curseforge.rs

@@ -0,0 +1,267 @@
+use crate::api::search_cancellation::SearchCancellation;
+use crate::api::{Result, TheseusSerializableError};
+use theseus::curseforge::{
+    CurseForgeCapability, CurseForgeCategory, CurseForgeFile,
+    CurseForgeFilesRequest, CurseForgeFilesResponse,
+    CurseForgeFingerprintResult, CurseForgeInstallRequest,
+    CurseForgeInstallResult, CurseForgeManualDownload,
+    CurseForgeManualDownloadImport, CurseForgeManualDownloadScanResult,
+    CurseForgeModpackInstallRequest, CurseForgeModpackInstallResult,
+    CurseForgeProject, CurseForgeRecognitionResult, CurseForgeSearchRequest,
+    UnifiedSearchResponse,
+};
+use theseus::prelude::CacheBehaviour;
+
+pub fn init<R: tauri::Runtime>() -> tauri::plugin::TauriPlugin<R> {
+    tauri::plugin::Builder::new("curseforge")
+        .invoke_handler(tauri::generate_handler![
+            curseforge_capability,
+            curseforge_validate_credentials,
+            curseforge_search_projects,
+            curseforge_get_project,
+            curseforge_get_projects,
+            curseforge_get_description,
+            curseforge_get_files,
+            curseforge_get_file,
+            curseforge_get_files_many,
+            curseforge_get_changelog,
+            curseforge_get_download_url,
+            curseforge_get_categories,
+            curseforge_match_fingerprints,
+            curseforge_install_file,
+            curseforge_preview_install_file,
+            curseforge_update_installed_file,
+            curseforge_switch_installed_file_version,
+            curseforge_recognize_instance_files,
+            curseforge_import_manual_downloads,
+            curseforge_list_pending_manual_downloads,
+            curseforge_import_pending_manual_download_file,
+            curseforge_configure_manual_download_watcher,
+            curseforge_install_modpack,
+            curseforge_update_managed_modpack,
+        ])
+        .build()
+}
+
+#[tauri::command]
+pub fn curseforge_capability() -> CurseForgeCapability {
+    theseus::curseforge::capability()
+}
+
+#[tauri::command]
+pub async fn curseforge_validate_credentials() -> Result<CurseForgeCapability> {
+    Ok(theseus::curseforge::validate_credentials().await?)
+}
+
+#[tauri::command]
+pub async fn curseforge_search_projects(
+    request: CurseForgeSearchRequest,
+    request_id: Option<String>,
+) -> Result<UnifiedSearchResponse> {
+    let Some(request_id) = request_id else {
+        return Ok(theseus::curseforge::search_projects(request).await?);
+    };
+    let cancellation = SearchCancellation::register(request_id);
+
+    tokio::select! {
+        result = theseus::curseforge::search_projects(request) => Ok(result?),
+        _ = cancellation.cancelled() => Err(TheseusSerializableError::SearchCancelled(
+            "CurseForge browse search".to_string(),
+        )),
+    }
+}
+
+#[tauri::command]
+pub async fn curseforge_get_project(
+    project_id: u32,
+) -> Result<CurseForgeProject> {
+    Ok(theseus::curseforge::get_project(project_id).await?)
+}
+
+#[tauri::command]
+pub async fn curseforge_get_projects(
+    project_ids: Vec<u32>,
+    cache_behaviour: Option<CacheBehaviour>,
+) -> Result<Vec<CurseForgeProject>> {
+    Ok(theseus::curseforge::get_projects_with_cache_behaviour(
+        project_ids,
+        cache_behaviour,
+    )
+    .await?)
+}
+
+#[tauri::command]
+pub async fn curseforge_get_description(project_id: u32) -> Result<String> {
+    Ok(theseus::curseforge::get_description(project_id).await?)
+}
+
+#[tauri::command]
+pub async fn curseforge_get_files(
+    project_id: u32,
+    request: CurseForgeFilesRequest,
+) -> Result<CurseForgeFilesResponse> {
+    Ok(theseus::curseforge::get_files(project_id, request).await?)
+}
+
+#[tauri::command]
+pub async fn curseforge_get_file(
+    project_id: u32,
+    file_id: u32,
+) -> Result<CurseForgeFile> {
+    Ok(theseus::curseforge::get_file(project_id, file_id).await?)
+}
+
+#[tauri::command]
+pub async fn curseforge_get_files_many(
+    file_ids: Vec<u32>,
+) -> Result<Vec<CurseForgeFile>> {
+    Ok(theseus::curseforge::get_files_many(file_ids).await?)
+}
+
+#[tauri::command]
+pub async fn curseforge_get_changelog(
+    project_id: u32,
+    file_id: u32,
+) -> Result<String> {
+    Ok(theseus::curseforge::get_changelog(project_id, file_id).await?)
+}
+
+#[tauri::command]
+pub async fn curseforge_get_download_url(
+    project_id: u32,
+    file_id: u32,
+) -> Result<Option<String>> {
+    Ok(theseus::curseforge::get_download_url(project_id, file_id).await?)
+}
+
+#[tauri::command]
+pub async fn curseforge_get_categories(
+    class_id: Option<u32>,
+) -> Result<Vec<CurseForgeCategory>> {
+    Ok(theseus::curseforge::get_categories(class_id).await?)
+}
+
+#[tauri::command]
+pub async fn curseforge_match_fingerprints(
+    fingerprints: Vec<u64>,
+) -> Result<CurseForgeFingerprintResult> {
+    Ok(theseus::curseforge::match_fingerprints(fingerprints).await?)
+}
+
+#[tauri::command]
+pub async fn curseforge_install_file(
+    request: CurseForgeInstallRequest,
+) -> Result<CurseForgeInstallResult> {
+    Ok(theseus::curseforge::install_file(request).await?)
+}
+
+#[tauri::command]
+pub async fn curseforge_preview_install_file(
+    request: CurseForgeInstallRequest,
+) -> Result<theseus::curseforge::CurseForgeInstallPreview> {
+    Ok(theseus::curseforge::preview_install_file(request).await?)
+}
+
+#[tauri::command]
+pub async fn curseforge_update_installed_file(
+    instance_id: String,
+    relative_path: String,
+) -> Result<CurseForgeInstallResult> {
+    Ok(
+        theseus::curseforge::update_installed_file(
+            &instance_id,
+            &relative_path,
+        )
+        .await?,
+    )
+}
+
+#[tauri::command]
+pub async fn curseforge_switch_installed_file_version(
+    instance_id: String,
+    relative_path: String,
+    file_id: u32,
+) -> Result<CurseForgeInstallResult> {
+    Ok(theseus::curseforge::switch_installed_file_version(
+        &instance_id,
+        &relative_path,
+        file_id,
+    )
+    .await?)
+}
+
+#[tauri::command]
+pub async fn curseforge_recognize_instance_files(
+    instance_id: String,
+) -> Result<CurseForgeRecognitionResult> {
+    Ok(theseus::curseforge::recognize_instance_files(&instance_id).await?)
+}
+
+#[tauri::command]
+pub async fn curseforge_import_manual_downloads(
+    instance_id: String,
+    scan_directory: Option<std::path::PathBuf>,
+) -> Result<CurseForgeManualDownloadScanResult> {
+    Ok(theseus::curseforge::import_manual_downloads(
+        &instance_id,
+        scan_directory,
+    )
+    .await?)
+}
+
+#[tauri::command]
+pub async fn curseforge_list_pending_manual_downloads(
+    instance_id: String,
+) -> Result<Vec<CurseForgeManualDownload>> {
+    Ok(
+        theseus::curseforge::list_pending_manual_downloads(&instance_id)
+            .await?,
+    )
+}
+
+#[tauri::command]
+pub async fn curseforge_import_pending_manual_download_file(
+    instance_id: String,
+    project_id: u32,
+    file_id: u32,
+    source_path: std::path::PathBuf,
+) -> Result<CurseForgeManualDownloadImport> {
+    Ok(theseus::curseforge::import_pending_manual_download_file(
+        &instance_id,
+        project_id,
+        file_id,
+        source_path,
+    )
+    .await?)
+}
+
+#[tauri::command]
+pub async fn curseforge_configure_manual_download_watcher(
+    enabled: bool,
+    scan_directory: Option<std::path::PathBuf>,
+) -> Result<Option<String>> {
+    Ok(theseus::curseforge::configure_manual_download_watcher(
+        enabled,
+        scan_directory,
+    )
+    .await?)
+}
+
+#[tauri::command]
+pub async fn curseforge_install_modpack(
+    request: CurseForgeModpackInstallRequest,
+) -> Result<CurseForgeModpackInstallResult> {
+    Ok(theseus::curseforge::install_modpack(request).await?)
+}
+
+#[tauri::command]
+pub async fn curseforge_update_managed_modpack(
+    instance_id: String,
+    file_id: u32,
+) -> Result<theseus::install::InstallJobSnapshot> {
+    Ok(theseus::install::runner::update_managed_curseforge_modpack(
+        instance_id,
+        file_id,
+    )
+    .await?)
+}