feat(tauri): Migrate from Tauri v1 to v2

# Summary
This commit completes the migration from Tauri v1 to v2, resolves configuration issues, upgrades Next.js, and adds test coverage for critical components to ensure stability during the transition.

# Details
## Tauri v2 Migration
- Updated Tauri dependencies to v2.3.0 series in package.json
- Restructured build configuration in `/app/config/build.ts` to align with Tauri v2 requirements
- Fixed imports and API usage patterns across the codebase
- Added compatibility layer for window.__TAURI__ references to maintain backward compatibility

## Next.js Issues
- Upgraded Next.js from 14.1.1 to 14.2.24
- Resolved caching problems with Server Actions
- Updated eslint-config-next to match the new version
- Cleared Next.js cache and temporary files to address build issues

## Testing & Stability
- Added comprehensive tests for `stream.ts` to verify streaming functionality
- Created mocks for Tauri API to support test environment
- Verified that critical functionality continues to work correctly
- Translated all comments to English for consistency

## Infrastructure
- Fixed peer dependency warnings during installation
- Ensured proper integration with Tauri v2 plugins (clipboard-manager, dialog, fs, http, notification, shell, updater, window-state)

# Approach
Prioritized stability by:
1. Making minimal necessary changes to configuration files
2. Preserving most `window.__TAURI__` calls as they still function in v2
3. Planning gradual migration to new APIs with test coverage for critical components
4. Documenting areas that will require future attention

# Testing
- Created unit tests for critical streaming functionality
- Performed manual testing of key application features
- Verified successful build and launch with Tauri v2

# Future Work
- Future PRs will gradually replace deprecated Tauri v1 API calls with v2 equivalents
- Additional test coverage will be added for other critical components

src-tauri/Cargo.toml

@@ -12,38 +12,31 @@ rust-version = "1.60"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [build-dependencies]
-tauri-build = { version = "1.5.1", features = [] }
+tauri-build = { version = "2", features = [] }
 
 [dependencies]
 serde_json = "1.0"
 serde = { version = "1.0", features = ["derive"] }
-tauri = { version = "1.5.4", features = [ "http-all",
-    "notification-all",
-    "fs-all",
-    "clipboard-all",
-    "dialog-all",
-    "shell-open",
-    "updater",
-    "window-close",
-    "window-hide",
-    "window-maximize",
-    "window-minimize",
-    "window-set-icon",
-    "window-set-ignore-cursor-events",
-    "window-set-resizable",
-    "window-show",
-    "window-start-dragging",
-    "window-unmaximize",
-    "window-unminimize",
+tauri = { version = "2", features = [
 ] }
-tauri-plugin-window-state = { git = "https://github.com/tauri-apps/plugins-workspace", branch = "v1" }
+tauri-plugin-window-state = { version = "2" }
 percent-encoding = "2.3.1"
 reqwest = "0.11.18"
 futures-util = "0.3.30"
 bytes = "1.7.2"
+log = "0.4.21"
+tauri-plugin-dialog = "2"
+tauri-plugin-shell = "2"
+tauri-plugin-notification = "2"
+tauri-plugin-fs = "2"
+tauri-plugin-http = "2"
+tauri-plugin-clipboard-manager = "2"
 
 [features]
 # this feature is used for production builds or when `devPath` points to the filesystem and the built-in dev server is disabled.
 # If you use cargo directly instead of tauri's cli you can use this feature flag to switch between tauri's `dev` and `build` modes.
 # DO NOT REMOVE!!
 custom-protocol = ["tauri/custom-protocol"]
+
+[target.'cfg(not(any(target_os = "android", target_os = "ios")))'.dependencies]
+tauri-plugin-updater = "2"

src-tauri/build.rs

@@ -1,3 +1,3 @@
 fn main() {
-  tauri_build::build()
+    tauri_build::build()
 }

src-tauri/capabilities/desktop.json

@@ -0,0 +1,14 @@
+{
+  "identifier": "desktop-capability",
+  "platforms": [
+    "macOS",
+    "windows",
+    "linux"
+  ],
+  "windows": [
+    "main"
+  ],
+  "permissions": [
+    "updater:default"
+  ]
+}

src-tauri/capabilities/migrated.json

@@ -0,0 +1,57 @@
+{
+  "identifier": "migrated",
+  "description": "permissions that were migrated from v1",
+  "local": true,
+  "windows": [
+    "main"
+  ],
+  "permissions": [
+    "core:default",
+    "fs:allow-read-file",
+    "fs:allow-write-file",
+    "fs:allow-read-dir",
+    "fs:allow-copy-file",
+    "fs:allow-mkdir",
+    "fs:allow-remove",
+    "fs:allow-remove",
+    "fs:allow-rename",
+    "fs:allow-exists",
+    "core:window:allow-set-resizable",
+    "core:window:allow-maximize",
+    "core:window:allow-unmaximize",
+    "core:window:allow-minimize",
+    "core:window:allow-unminimize",
+    "core:window:allow-show",
+    "core:window:allow-hide",
+    "core:window:allow-close",
+    "core:window:allow-set-icon",
+    "core:window:allow-set-ignore-cursor-events",
+    "core:window:allow-start-dragging",
+    "shell:allow-open",
+    "dialog:allow-open",
+    "dialog:allow-save",
+    "dialog:allow-message",
+    "dialog:allow-ask",
+    "dialog:allow-confirm",
+    {
+      "identifier": "http:default",
+      "allow": [
+        {
+          "url": "https://*/"
+        },
+        {
+          "url": "http://*/"
+        }
+      ]
+    },
+    "notification:default",
+    "clipboard-manager:allow-read-text",
+    "clipboard-manager:allow-write-text",
+    "dialog:default",
+    "shell:default",
+    "notification:default",
+    "fs:default",
+    "http:default",
+    "clipboard-manager:default"
+  ]
+}

src-tauri/gen/schemas/capabilities.json

@@ -0,0 +1 @@
+{"desktop-capability":{"identifier":"desktop-capability","description":"","local":true,"windows":["main"],"permissions":["updater:default"],"platforms":["macOS","windows","linux"]},"migrated":{"identifier":"migrated","description":"permissions that were migrated from v1","local":true,"windows":["main"],"permissions":["core:default","fs:allow-read-file","fs:allow-write-file","fs:allow-read-dir","fs:allow-copy-file","fs:allow-mkdir","fs:allow-remove","fs:allow-remove","fs:allow-rename","fs:allow-exists","core:window:allow-set-resizable","core:window:allow-maximize","core:window:allow-unmaximize","core:window:allow-minimize","core:window:allow-unminimize","core:window:allow-show","core:window:allow-hide","core:window:allow-close","core:window:allow-set-icon","core:window:allow-set-ignore-cursor-events","core:window:allow-start-dragging","shell:allow-open","dialog:allow-open","dialog:allow-save","dialog:allow-message","dialog:allow-ask","dialog:allow-confirm",{"identifier":"http:default","allow":[{"url":"https://*/"},{"url":"http://*/"}]},"notification:default","clipboard-manager:allow-read-text","clipboard-manager:allow-write-text","dialog:default","shell:default","notification:default","fs:default","http:default","clipboard-manager:default"]}}

src-tauri/src/main.rs

@@ -4,9 +4,16 @@
 mod stream;
 
 fn main() {
-  tauri::Builder::default()
-    .invoke_handler(tauri::generate_handler![stream::stream_fetch])
-    .plugin(tauri_plugin_window_state::Builder::default().build())
-    .run(tauri::generate_context!())
-    .expect("error while running tauri application");
+    tauri::Builder::default()
+        .plugin(tauri_plugin_updater::Builder::new().build())
+        .plugin(tauri_plugin_clipboard_manager::init())
+        .plugin(tauri_plugin_http::init())
+        .plugin(tauri_plugin_fs::init())
+        .plugin(tauri_plugin_notification::init())
+        .plugin(tauri_plugin_shell::init())
+        .plugin(tauri_plugin_dialog::init())
+        .invoke_handler(tauri::generate_handler![stream::stream_fetch])
+        .plugin(tauri_plugin_window_state::Builder::default().build())
+        .run(tauri::generate_context!())
+        .expect("error while running tauri application");
 }

src-tauri/src/stream.rs

@@ -1,145 +1,176 @@
 //
 //
 
-use std::time::Duration;
+use futures_util::StreamExt;
+use std::collections::HashMap;
 use std::error::Error;
 use std::sync::atomic::{AtomicU32, Ordering};
-use std::collections::HashMap;
-use futures_util::{StreamExt};
-use reqwest::Client;
-use reqwest::header::{HeaderName, HeaderMap};
+use std::time::Duration;
+use tauri::Emitter;
+use tauri_plugin_http::reqwest;
+use tauri_plugin_http::reqwest::header::{HeaderMap, HeaderName};
+use tauri_plugin_http::reqwest::Client;
 
 static REQUEST_COUNTER: AtomicU32 = AtomicU32::new(0);
 
 #[derive(Debug, Clone, serde::Serialize)]
 pub struct StreamResponse {
-  request_id: u32,
-  status: u16,
-  status_text: String,
-  headers: HashMap<String, String>
+    request_id: u32,
+    status: u16,
+    status_text: String,
+    headers: HashMap<String, String>,
 }
 
 #[derive(Clone, serde::Serialize)]
 pub struct EndPayload {
-  request_id: u32,
-  status: u16,
+    request_id: u32,
+    status: u16,
 }
 
 #[derive(Clone, serde::Serialize)]
 pub struct ChunkPayload {
-  request_id: u32,
-  chunk: bytes::Bytes,
+    request_id: u32,
+    chunk: Vec<u8>,
 }
 
 #[tauri::command]
 pub async fn stream_fetch(
-  window: tauri::Window,
-  method: String,
-  url: String,
-  headers: HashMap<String, String>,
-  body: Vec<u8>,
+    window: tauri::WebviewWindow,
+    method: String,
+    url: String,
+    headers: HashMap<String, String>,
+    body: Vec<u8>,
 ) -> Result<StreamResponse, String> {
+    let event_name = "stream-response";
+    let request_id = REQUEST_COUNTER.fetch_add(1, Ordering::SeqCst);
 
-  let event_name = "stream-response";
-  let request_id = REQUEST_COUNTER.fetch_add(1, Ordering::SeqCst);
-
-  let mut _headers = HeaderMap::new();
-  for (key, value) in &headers {
-    _headers.insert(key.parse::<HeaderName>().unwrap(), value.parse().unwrap());
-  }
-
-  // println!("method: {:?}", method);
-  // println!("url: {:?}", url);
-  // println!("headers: {:?}", headers);
-  // println!("headers: {:?}", _headers);
-
-  let method = method.parse::<reqwest::Method>().map_err(|err| format!("failed to parse method: {}", err))?;
-  let client = Client::builder()
-    .default_headers(_headers)
-    .redirect(reqwest::redirect::Policy::limited(3))
-    .connect_timeout(Duration::new(3, 0))
-    .build()
-    .map_err(|err| format!("failed to generate client: {}", err))?;
-
-  let mut request = client.request(
-    method.clone(),
-    url.parse::<reqwest::Url>().map_err(|err| format!("failed to parse url: {}", err))?
-  );
-
-  if method == reqwest::Method::POST || method == reqwest::Method::PUT || method == reqwest::Method::PATCH {
-    let body = bytes::Bytes::from(body);
-    // println!("body: {:?}", body);
-    request = request.body(body);
-  }
-
-  // println!("client: {:?}", client);
-  // println!("request: {:?}", request);
-
-  let response_future = request.send();
-
-  let res = response_future.await;
-  let response = match res {
-    Ok(res) => {
-      // get response and emit to client
-      let mut headers = HashMap::new();
-      for (name, value) in res.headers() {
-        headers.insert(
-          name.as_str().to_string(),
-          std::str::from_utf8(value.as_bytes()).unwrap().to_string()
-        );
-      }
-      let status = res.status().as_u16();
-
-      tauri::async_runtime::spawn(async move {
-        let mut stream = res.bytes_stream();
-
-        while let Some(chunk) = stream.next().await {
-          match chunk {
-            Ok(bytes) => {
-              // println!("chunk: {:?}", bytes);
-              if let Err(e) = window.emit(event_name, ChunkPayload{ request_id, chunk: bytes }) {
-                println!("Failed to emit chunk payload: {:?}", e);
-              }
-            }
-            Err(err) => {
-              println!("Error chunk: {:?}", err);
-            }
-          }
-        }
-        if let Err(e) = window.emit(event_name, EndPayload{ request_id, status: 0 }) {
-          println!("Failed to emit end payload: {:?}", e);
-        }
-      });
-
-      StreamResponse {
-        request_id,
-        status,
-        status_text: "OK".to_string(),
-        headers,
-      }
+    let mut _headers = HeaderMap::new();
+    for (key, value) in &headers {
+        _headers.insert(key.parse::<HeaderName>().unwrap(), value.parse().unwrap());
     }
-    Err(err) => {
-      let error: String = err.source()
-        .map(|e| e.to_string())
-        .unwrap_or_else(|| "Unknown error occurred".to_string());
-      println!("Error response: {:?}", error);
-      tauri::async_runtime::spawn( async move {
-        if let Err(e) = window.emit(event_name, ChunkPayload{ request_id, chunk: error.into() }) {
-          println!("Failed to emit chunk payload: {:?}", e);
-        }
-        if let Err(e) = window.emit(event_name, EndPayload{ request_id, status: 0 }) {
-          println!("Failed to emit end payload: {:?}", e);
-        }
-      });
-      StreamResponse {
-        request_id,
-        status: 599,
-        status_text: "Error".to_string(),
-        headers: HashMap::new(),
-      }
+
+    // println!("method: {:?}", method);
+    // println!("url: {:?}", url);
+    // println!("headers: {:?}", headers);
+    // println!("headers: {:?}", _headers);
+
+    let method = method
+        .parse::<reqwest::Method>()
+        .map_err(|err| format!("failed to parse method: {}", err))?;
+    let client = Client::builder()
+        .default_headers(_headers)
+        .redirect(reqwest::redirect::Policy::limited(3))
+        .connect_timeout(Duration::new(3, 0))
+        .build()
+        .map_err(|err| format!("failed to generate client: {}", err))?;
+
+    let mut request = client.request(
+        method.clone(),
+        url.parse::<reqwest::Url>()
+            .map_err(|err| format!("failed to parse url: {}", err))?,
+    );
+
+    if method == reqwest::Method::POST
+        || method == reqwest::Method::PUT
+        || method == reqwest::Method::PATCH
+    {
+        let body = bytes::Bytes::from(body);
+        // println!("body: {:?}", body);
+        request = request.body(body);
     }
-  };
-  // println!("Response: {:?}", response);
-  Ok(response)
+
+    // println!("client: {:?}", client);
+    // println!("request: {:?}", request);
+
+    let response_future = request.send();
+
+    let res = response_future.await;
+    let response = match res {
+        Ok(res) => {
+            // get response and emit to client
+            let mut headers = HashMap::new();
+            for (name, value) in res.headers() {
+                headers.insert(
+                    name.as_str().to_string(),
+                    std::str::from_utf8(value.as_bytes()).unwrap().to_string(),
+                );
+            }
+            let status = res.status().as_u16();
+
+            tauri::async_runtime::spawn(async move {
+                let mut stream = res.bytes_stream();
+
+                while let Some(chunk) = stream.next().await {
+                    match chunk {
+                        Ok(bytes) => {
+                            // println!("chunk: {:?}", bytes);
+                            if let Err(e) = window.emit(
+                                event_name,
+                                ChunkPayload {
+                                    request_id,
+                                    chunk: bytes.to_vec(),
+                                },
+                            ) {
+                                println!("Failed to emit chunk payload: {:?}", e);
+                            }
+                        }
+                        Err(err) => {
+                            println!("Error chunk: {:?}", err);
+                        }
+                    }
+                }
+                if let Err(e) = window.emit(
+                    event_name,
+                    EndPayload {
+                        request_id,
+                        status: 0,
+                    },
+                ) {
+                    println!("Failed to emit end payload: {:?}", e);
+                }
+            });
+
+            StreamResponse {
+                request_id,
+                status,
+                status_text: "OK".to_string(),
+                headers,
+            }
+        }
+        Err(err) => {
+            let error: String = err
+                .source()
+                .map(|e| e.to_string())
+                .unwrap_or_else(|| "Unknown error occurred".to_string());
+            println!("Error response: {:?}", error);
+            tauri::async_runtime::spawn(async move {
+                if let Err(e) = window.emit(
+                    event_name,
+                    ChunkPayload {
+                        request_id,
+                        chunk: error.into_bytes(),
+                    },
+                ) {
+                    println!("Failed to emit chunk payload: {:?}", e);
+                }
+                if let Err(e) = window.emit(
+                    event_name,
+                    EndPayload {
+                        request_id,
+                        status: 0,
+                    },
+                ) {
+                    println!("Failed to emit end payload: {:?}", e);
+                }
+            });
+            StreamResponse {
+                request_id,
+                status: 599,
+                status_text: "Error".to_string(),
+                headers: HashMap::new(),
+            }
+        }
+    };
+    // println!("Response: {:?}", response);
+    Ok(response)
 }
-

src-tauri/tauri.conf.json

@@ -3,108 +3,61 @@
   "build": {
     "beforeBuildCommand": "yarn export",
     "beforeDevCommand": "yarn export:dev",
-    "devPath": "http://localhost:3000",
-    "distDir": "../out",
-    "withGlobalTauri": true
+    "frontendDist": "../out",
+    "devUrl": "http://localhost:3000"
   },
-  "package": {
-    "productName": "NextChat",
-    "version": "2.15.8"
-  },
-  "tauri": {
-    "allowlist": {
-      "all": false,
-      "shell": {
-        "all": false,
-        "open": true
-      },
-      "dialog": {
-        "all": true,
-        "ask": true,
-        "confirm": true,
-        "message": true,
-        "open": true,
-        "save": true
-      },
-      "clipboard": {
-        "all": true,
-        "writeText": true,
-        "readText": true
-      },
-      "window": {
-        "all": false,
-        "close": true,
-        "hide": true,
-        "maximize": true,
-        "minimize": true,
-        "setIcon": true,
-        "setIgnoreCursorEvents": true,
-        "setResizable": true,
-        "show": true,
-        "startDragging": true,
-        "unmaximize": true,
-        "unminimize": true
-      },
-      "fs": {
-        "all": true
-      },
-      "notification": {
-        "all": true
-      },
-      "http": {
-        "all": true,
-        "request": true,
-        "scope": ["https://*", "http://*"]
-      }
+  "bundle": {
+    "active": true,
+    "category": "DeveloperTool",
+    "copyright": "2023, Zhang Yifei All Rights Reserved.",
+    "targets": "all",
+    "externalBin": [],
+    "icon": [
+      "icons/32x32.png",
+      "icons/128x128.png",
+      "icons/128x128@2x.png",
+      "icons/icon.icns",
+      "icons/icon.ico"
+    ],
+    "windows": {
+      "certificateThumbprint": null,
+      "digestAlgorithm": "sha256",
+      "timestampUrl": ""
     },
-    "bundle": {
-      "active": true,
-      "category": "DeveloperTool",
-      "copyright": "2023, Zhang Yifei All Rights Reserved.",
+    "longDescription": "NextChat is a cross-platform ChatGPT client, including Web/Win/Linux/OSX/PWA.",
+    "macOS": {
+      "entitlements": null,
+      "exceptionDomain": "",
+      "frameworks": [],
+      "providerShortName": null,
+      "signingIdentity": null
+    },
+    "resources": [],
+    "shortDescription": "NextChat App",
+    "linux": {
       "deb": {
         "depends": []
-      },
-      "externalBin": [],
-      "icon": [
-        "icons/32x32.png",
-        "icons/128x128.png",
-        "icons/128x128@2x.png",
-        "icons/icon.icns",
-        "icons/icon.ico"
-      ],
-      "identifier": "com.yida.chatgpt.next.web",
-      "longDescription": "NextChat is a cross-platform ChatGPT client, including Web/Win/Linux/OSX/PWA.",
-      "macOS": {
-        "entitlements": null,
-        "exceptionDomain": "",
-        "frameworks": [],
-        "providerShortName": null,
-        "signingIdentity": null
-      },
-      "resources": [],
-      "shortDescription": "NextChat App",
-      "targets": "all",
-      "windows": {
-        "certificateThumbprint": null,
-        "digestAlgorithm": "sha256",
-        "timestampUrl": ""
       }
     },
-    "security": {
-      "csp": null,
-      "dangerousUseHttpScheme": true
-    },
+    "createUpdaterArtifacts": "v1Compatible"
+  },
+  "productName": "NextChat",
+  "mainBinaryName": "NextChat",
+  "version": "2.15.8",
+  "identifier": "com.yida.chatgpt.next.web",
+  "plugins": {
     "updater": {
-      "active": true,
-      "endpoints": [
-        "https://github.com/ChatGPTNextWeb/ChatGPT-Next-Web/releases/latest/download/latest.json"
-      ],
-      "dialog": true,
       "windows": {
         "installMode": "passive"
       },
+      "endpoints": [
+        "https://github.com/ChatGPTNextWeb/ChatGPT-Next-Web/releases/latest/download/latest.json"
+      ],
       "pubkey": "dW50cnVzdGVkIGNvbW1lbnQ6IG1pbmlzaWduIHB1YmxpYyBrZXk6IERFNDE4MENFM0Y1RTZBOTQKUldTVWFsNC96b0JCM3RqM2NmMnlFTmxIaStRaEJrTHNOU2VqRVlIV1hwVURoWUdVdEc1eDcxVEYK"
-    },
+    }
+  },
+  "app": {
+    "withGlobalTauri": true,
     "windows": [
       {
         "fullscreen": false,
@@ -113,8 +66,12 @@
         "title": "NextChat",
         "width": 960,
         "hiddenTitle": true,
-        "titleBarStyle": "Overlay"
+        "titleBarStyle": "Overlay",
+        "useHttpsScheme": false
       }
-    ]
+    ],
+    "security": {
+      "csp": null
+    }
   }
-}
+}