Merge 956ec96d51 into 3809375694

app/components/exporter.tsx

@@ -40,6 +40,8 @@ import { type ClientApi, getClientApi } from "../client/api";
 import { getMessageTextContent } from "../utils";
 import { MaskAvatar } from "./mask";
 import clsx from "clsx";
+import { save } from "@tauri-apps/plugin-dialog";
+import { writeFile } from "@tauri-apps/plugin-fs";
 
 const Markdown = dynamic(async () => (await import("./markdown")).Markdown, {
   loading: () => <LoadingIcon />,
@@ -456,7 +458,7 @@ export function ImagePreviewer(props: {
 
       if (isMobile || (isApp && window.__TAURI__)) {
         if (isApp && window.__TAURI__) {
-          const result = await window.__TAURI__.dialog.save({
+          const result = await save({
             defaultPath: `${props.topic}.png`,
             filters: [
               {
@@ -474,7 +476,7 @@ export function ImagePreviewer(props: {
             const response = await fetch(blob);
             const buffer = await response.arrayBuffer();
             const uint8Array = new Uint8Array(buffer);
-            await window.__TAURI__.fs.writeBinaryFile(result, uint8Array);
+            await writeFile(result, uint8Array);
             showToast(Locale.Download.Success);
           } else {
             showToast(Locale.Download.Failed);

app/config/build.ts

@@ -10,7 +10,7 @@ export const getBuildConfig = () => {
 
   const buildMode = process.env.BUILD_MODE ?? "standalone";
   const isApp = !!process.env.BUILD_APP;
-  const version = "v" + tauriConfig.package.version;
+  const version = "v" + tauriConfig.version;
 
   const commitInfo = (() => {
     try {

app/store/update.ts

@@ -10,6 +10,11 @@ import { clientUpdate } from "../utils";
 import ChatGptIcon from "../icons/chatgpt.png";
 import Locale from "../locales";
 import { ClientApi } from "../client/api";
+import {
+  isPermissionGranted,
+  requestPermission,
+  sendNotification,
+} from "@tauri-apps/plugin-notification";
 
 const ONE_MINUTE = 60 * 1000;
 const isApp = !!getClientConfig()?.isApp;
@@ -90,42 +95,39 @@ export const useUpdateStore = createPersistStore(
           remoteVersion: remoteId,
         }));
         if (window.__TAURI__?.notification && isApp) {
-          // Check if notification permission is granted
+          try {
-          await window.__TAURI__?.notification
+            // Check if notification permission is granted
-            .isPermissionGranted()
+            const granted = await isPermissionGranted();
-            .then((granted) => {
+            if (!granted) {
-              if (!granted) {
+              // Request permission to show notifications
-                return;
+              const permission = await requestPermission();
-              } else {
+              if (permission !== "granted") return;
-                // Request permission to show notifications
+            }
-                window.__TAURI__?.notification
+
-                  .requestPermission()
+            if (version === remoteId) {
-                  .then((permission) => {
+              // Show a notification using Tauri
-                    if (permission === "granted") {
+              await sendNotification({
-                      if (version === remoteId) {
+                title: "NextChat",
-                        // Show a notification using Tauri
+                body: `${Locale.Settings.Update.IsLatest}`,
-                        window.__TAURI__?.notification.sendNotification({
+                icon: `${ChatGptIcon.src}`,
-                          title: "NextChat",
+                sound: "Default",
-                          body: `${Locale.Settings.Update.IsLatest}`,
+              });
-                          icon: `${ChatGptIcon.src}`,
+            } else {
-                          sound: "Default",
+              const updateMessage = Locale.Settings.Update.FoundUpdate(
-                        });
+                `${remoteId}`,
-                      } else {
+              );
-                        const updateMessage =
+              // Show a notification for the new version using Tauri
-                          Locale.Settings.Update.FoundUpdate(`${remoteId}`);
+              await sendNotification({
-                        // Show a notification for the new version using Tauri
+                title: "NextChat",
-                        window.__TAURI__?.notification.sendNotification({
+                body: updateMessage,
-                          title: "NextChat",
+                icon: `${ChatGptIcon.src}`,
-                          body: updateMessage,
+                sound: "Default",
-                          icon: `${ChatGptIcon.src}`,
+              });
-                          sound: "Default",
+              clientUpdate();
-                        });
+            }
-                        clientUpdate();
+          } catch (error) {
-                      }
+            console.error("[Notification Error]", error);
-                    }
+          }
-                  });
-              }
-            });
         }
         console.log("[Got Upstream] ", remoteId);
       } catch (error) {

app/utils.ts

@@ -12,6 +12,9 @@ import { fetch as tauriStreamFetch } from "./utils/stream";
 import { VISION_MODEL_REGEXES, EXCLUDE_VISION_MODEL_REGEXES } from "./constant";
 import { useAccessStore } from "./store";
 import { ModelSize } from "./typing";
+import { writeText } from "@tauri-apps/plugin-clipboard-manager";
+import { save } from "@tauri-apps/plugin-dialog";
+import { writeTextFile } from "@tauri-apps/plugin-fs";
 
 export function trimTopic(topic: string) {
   // Fix an issue where double quotes still show in the Indonesian language
@@ -20,15 +23,15 @@ export function trimTopic(topic: string) {
   return (
     topic
       // fix for gemini
-      .replace(/^["“”*]+|["“”*]+$/g, "")
+      .replace(/^["""*]+|["""*]+$/g, "")
-      .replace(/[，。！？”“"、,.!?*]*$/, "")
+      .replace(/[，。！？""""、,.!?*]*$/, "")
   );
 }
 
 export async function copyToClipboard(text: string) {
   try {
     if (window.__TAURI__) {
-      window.__TAURI__.writeText(text);
+      await writeText(text);
     } else {
       await navigator.clipboard.writeText(text);
     }
@@ -52,7 +55,7 @@ export async function copyToClipboard(text: string) {
 
 export async function downloadAs(text: string, filename: string) {
   if (window.__TAURI__) {
-    const result = await window.__TAURI__.dialog.save({
+    const result = await save({
       defaultPath: `${filename}`,
       filters: [
         {
@@ -68,7 +71,7 @@ export async function downloadAs(text: string, filename: string) {
 
     if (result !== null) {
       try {
-        await window.__TAURI__.fs.writeTextFile(result, text);
+        await writeTextFile(result, text);
         showToast(Locale.Download.Success);
       } catch (error) {
         showToast(Locale.Download.Failed);
@@ -448,24 +451,29 @@ export function getOperationId(operation: {
 
 export function clientUpdate() {
   // this a wild for updating client app
-  return window.__TAURI__?.updater
+  const tauriApp = window.__TAURI__;
+  if (!tauriApp || !tauriApp.updater) return Promise.resolve();
+
+  return tauriApp.updater
     .checkUpdate()
-    .then((updateResult) => {
+    .then((updateResult: any) => {
       if (updateResult.shouldUpdate) {
-        window.__TAURI__?.updater
+        return tauriApp.updater
           .installUpdate()
-          .then((result) => {
+          .then((result: any) => {
             showToast(Locale.Settings.Update.Success);
           })
-          .catch((e) => {
+          .catch((e: any) => {
             console.error("[Install Update Error]", e);
             showToast(Locale.Settings.Update.Failed);
           });
       }
+      return updateResult;
     })
-    .catch((e) => {
+    .catch((e: any) => {
       console.error("[Check Update Error]", e);
       showToast(Locale.Settings.Update.Failed);
+      return e;
     });
 }
 

app/utils/stream.ts

@@ -3,6 +3,9 @@
 // 1. invoke('stream_fetch', {url, method, headers, body}), get response with headers.
 // 2. listen event: `stream-response` multi times to get body
 
+import { invoke } from "@tauri-apps/api/core";
+import { listen } from "@tauri-apps/api/event";
+
 type ResponseEvent = {
   id: number;
   payload: {
@@ -27,8 +30,8 @@ export function fetch(url: string, options?: RequestInit): Promise<Response> {
       headers: _headers = {},
       body = [],
     } = options || {};
-    let unlisten: Function | undefined;
+    let unlisten: (() => void) | undefined;
-    let setRequestId: Function | undefined;
+    let setRequestId: ((value: number) => void) | undefined;
     const requestIdPromise = new Promise((resolve) => (setRequestId = resolve));
     const ts = new TransformStream();
     const writer = ts.writable.getWriter();
@@ -46,25 +49,24 @@ export function fetch(url: string, options?: RequestInit): Promise<Response> {
     if (signal) {
       signal.addEventListener("abort", () => close());
     }
-    // @ts-ignore 2. listen response multi times, and write to Response.body
+
-    window.__TAURI__.event
+    // Listen for stream response events
-      .listen("stream-response", (e: ResponseEvent) =>
+    listen("stream-response", (e: ResponseEvent) =>
-        requestIdPromise.then((request_id) => {
+      requestIdPromise.then((request_id) => {
-          const { request_id: rid, chunk, status } = e?.payload || {};
+        const { request_id: rid, chunk, status } = e?.payload || {};
-          if (request_id != rid) {
+        if (request_id != rid) {
-            return;
+          return;
-          }
+        }
-          if (chunk) {
+        if (chunk) {
-            writer.ready.then(() => {
+          writer.ready.then(() => {
-              writer.write(new Uint8Array(chunk));
+            writer.write(new Uint8Array(chunk));
-            });
+          });
-          } else if (status === 0) {
+        } else if (status === 0) {
-            // end of body
+          // end of body
-            close();
+          close();
-          }
+        }
-        }),
+      }),
-      )
+    ).then((u: () => void) => (unlisten = u));
-      .then((u: Function) => (unlisten = u));
 
     const headers: Record<string, string> = {
       Accept: "application/json, text/plain, */*",
@@ -74,17 +76,16 @@ export function fetch(url: string, options?: RequestInit): Promise<Response> {
     for (const item of new Headers(_headers || {})) {
       headers[item[0]] = item[1];
     }
-    return window.__TAURI__
+    return invoke<StreamResponse>("stream_fetch", {
-      .invoke("stream_fetch", {
+      method: method.toUpperCase(),
-        method: method.toUpperCase(),
+      url,
-        url,
+      headers,
-        headers,
+      // TODO FormData
-        // TODO FormData
+      body:
-        body:
+        typeof body === "string"
-          typeof body === "string"
+          ? Array.from(new TextEncoder().encode(body))
-            ? Array.from(new TextEncoder().encode(body))
+          : [],
-            : [],
+    })
-      })
       .then((res: StreamResponse) => {
         const { request_id, status, status_text: statusText, headers } = res;
         setRequestId?.(request_id);

package.json

@@ -26,6 +26,14 @@
     "@modelcontextprotocol/sdk": "^1.0.4",
     "@next/third-parties": "^14.1.0",
     "@svgr/webpack": "^6.5.1",
+    "@tauri-apps/plugin-clipboard-manager": "~2",
+    "@tauri-apps/plugin-dialog": "~2",
+    "@tauri-apps/plugin-fs": "~2",
+    "@tauri-apps/plugin-http": "~2",
+    "@tauri-apps/plugin-notification": "~2",
+    "@tauri-apps/plugin-shell": "~2",
+    "@tauri-apps/plugin-updater": "~2",
+    "@tauri-apps/plugin-window-state": "^2.2.1",
     "@vercel/analytics": "^0.1.11",
     "@vercel/speed-insights": "^1.0.2",
     "axios": "^1.7.5",
@@ -39,7 +47,7 @@
     "markdown-to-txt": "^2.0.1",
     "mermaid": "^10.6.1",
     "nanoid": "^5.0.3",
-    "next": "^14.1.1",
+    "next": "14.2.24",
     "node-fetch": "^3.3.1",
     "openapi-client-axios": "^7.5.5",
     "react": "^18.2.0",
@@ -59,8 +67,8 @@
     "zustand": "^4.3.8"
   },
   "devDependencies": {
-    "@tauri-apps/api": "^2.1.1",
+    "@tauri-apps/api": "^2.3.0",
-    "@tauri-apps/cli": "1.5.11",
+    "@tauri-apps/cli": "^2.3.1",
     "@testing-library/dom": "^10.4.0",
     "@testing-library/jest-dom": "^6.6.3",
     "@testing-library/react": "^16.1.0",
@@ -75,7 +83,7 @@
     "concurrently": "^8.2.2",
     "cross-env": "^7.0.3",
     "eslint": "^8.49.0",
-    "eslint-config-next": "13.4.19",
+    "eslint-config-next": "14.2.24",
     "eslint-config-prettier": "^8.8.0",
     "eslint-plugin-prettier": "^5.1.3",
     "eslint-plugin-unused-imports": "^3.2.0",

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",
+tauri = { version = "2", features = [
-    "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-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()
+    tauri::Builder::default()
-    .invoke_handler(tauri::generate_handler![stream::stream_fetch])
+        .plugin(tauri_plugin_updater::Builder::new().build())
-    .plugin(tauri_plugin_window_state::Builder::default().build())
+        .plugin(tauri_plugin_clipboard_manager::init())
-    .run(tauri::generate_context!())
+        .plugin(tauri_plugin_http::init())
-    .expect("error while running tauri application");
+        .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 std::time::Duration;
-use futures_util::{StreamExt};
+use tauri::Emitter;
-use reqwest::Client;
+use tauri_plugin_http::reqwest;
-use reqwest::header::{HeaderName, HeaderMap};
+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,
+    request_id: u32,
-  status: u16,
+    status: u16,
-  status_text: String,
+    status_text: String,
-  headers: HashMap<String, String>
+    headers: HashMap<String, String>,
 }
 
 #[derive(Clone, serde::Serialize)]
 pub struct EndPayload {
-  request_id: u32,
+    request_id: u32,
-  status: u16,
+    status: u16,
 }
 
 #[derive(Clone, serde::Serialize)]
 pub struct ChunkPayload {
-  request_id: u32,
+    request_id: u32,
-  chunk: bytes::Bytes,
+    chunk: Vec<u8>,
 }
 
 #[tauri::command]
 pub async fn stream_fetch(
-  window: tauri::Window,
+    window: tauri::WebviewWindow,
-  method: String,
+    method: String,
-  url: String,
+    url: String,
-  headers: HashMap<String, String>,
+    headers: HashMap<String, String>,
-  body: Vec<u8>,
+    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 mut _headers = HeaderMap::new();
-  let request_id = REQUEST_COUNTER.fetch_add(1, Ordering::SeqCst);
+    for (key, value) in &headers {
-
+        _headers.insert(key.parse::<HeaderName>().unwrap(), value.parse().unwrap());
-  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,
-      }
     }
-    Err(err) => {
+
-      let error: String = err.source()
+    // println!("method: {:?}", method);
-        .map(|e| e.to_string())
+    // println!("url: {:?}", url);
-        .unwrap_or_else(|| "Unknown error occurred".to_string());
+    // println!("headers: {:?}", headers);
-      println!("Error response: {:?}", error);
+    // println!("headers: {:?}", _headers);
-      tauri::async_runtime::spawn( async move {
+
-        if let Err(e) = window.emit(event_name, ChunkPayload{ request_id, chunk: error.into() }) {
+    let method = method
-          println!("Failed to emit chunk payload: {:?}", e);
+        .parse::<reqwest::Method>()
-        }
+        .map_err(|err| format!("failed to parse method: {}", err))?;
-        if let Err(e) = window.emit(event_name, EndPayload{ request_id, status: 0 }) {
+    let client = Client::builder()
-          println!("Failed to emit end payload: {:?}", e);
+        .default_headers(_headers)
-        }
+        .redirect(reqwest::redirect::Policy::limited(3))
-      });
+        .connect_timeout(Duration::new(3, 0))
-      StreamResponse {
+        .build()
-        request_id,
+        .map_err(|err| format!("failed to generate client: {}", err))?;
-        status: 599,
+
-        status_text: "Error".to_string(),
+    let mut request = client.request(
-        headers: HashMap::new(),
+        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);
+    // println!("client: {:?}", client);
-  Ok(response)
+    // 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",
+    "frontendDist": "../out",
-    "distDir": "../out",
+    "devUrl": "http://localhost:3000"
-    "withGlobalTauri": true
   },
-  "package": {
+  "bundle": {
-    "productName": "NextChat",
+    "active": true,
-    "version": "2.15.8"
+    "category": "DeveloperTool",
-  },
+    "copyright": "2023, Zhang Yifei All Rights Reserved.",
-  "tauri": {
+    "targets": "all",
-    "allowlist": {
+    "externalBin": [],
-      "all": false,
+    "icon": [
-      "shell": {
+      "icons/32x32.png",
-        "all": false,
+      "icons/128x128.png",
-        "open": true
+      "icons/128x128@2x.png",
-      },
+      "icons/icon.icns",
-      "dialog": {
+      "icons/icon.ico"
-        "all": true,
+    ],
-        "ask": true,
+    "windows": {
-        "confirm": true,
+      "certificateThumbprint": null,
-        "message": true,
+      "digestAlgorithm": "sha256",
-        "open": true,
+      "timestampUrl": ""
-        "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": {
+    "longDescription": "NextChat is a cross-platform ChatGPT client, including Web/Win/Linux/OSX/PWA.",
-      "active": true,
+    "macOS": {
-      "category": "DeveloperTool",
+      "entitlements": null,
-      "copyright": "2023, Zhang Yifei All Rights Reserved.",
+      "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": {
+    "createUpdaterArtifacts": "v1Compatible"
-      "csp": null,
+  },
-      "dangerousUseHttpScheme": true
+  "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
+    }
   }
 }

test/stream-fetch.test.ts

@@ -0,0 +1,167 @@
+import { jest } from '@jest/globals';
+
+// Create mocks
+const mockInvoke = jest.fn();
+const mockListen = jest.fn();
+
+// Mock Tauri modules before import
+jest.mock('@tauri-apps/api/core', () => ({
+  invoke: (...args: any[]) => mockInvoke(...args)
+}));
+
+jest.mock('@tauri-apps/api/event', () => ({
+  listen: (...args: any[]) => mockListen(...args)
+}));
+
+// Import function after mocking
+import { fetch as streamFetch } from '../app/utils/stream';
+import { invoke } from '@tauri-apps/api/core';
+import { listen } from '@tauri-apps/api/event';
+
+// Mock global objects
+// @ts-ignore
+global.TransformStream = class TransformStream {
+  writable = {
+    getWriter: () => ({
+      ready: Promise.resolve(),
+      // @ts-ignore
+      write: jest.fn().mockResolvedValue(undefined as any),
+      // @ts-ignore
+      close: jest.fn().mockResolvedValue(undefined as any)
+    })
+  };
+  readable = {} as any;
+} as any;
+
+// Add Response to global context
+global.Response = class Response {
+  constructor(public body: any, public init: any) {
+    Object.assign(this, init);
+  }
+  status: number = 200;
+  statusText: string = 'OK';
+  headers: any = {};
+} as any;
+
+describe('stream-fetch', () => {
+  let originalFetch: any;
+  let originalWindow: any;
+
+  beforeAll(() => {
+    originalFetch = global.fetch;
+    originalWindow = global.window;
+
+    // Mock window object
+    Object.defineProperty(global, 'window', {
+      value: {
+        __TAURI__: true,
+        __TAURI_INTERNALS__: {
+          transformCallback: (callback: Function) => callback,
+          invoke: mockInvoke
+        },
+        fetch: jest.fn(),
+        Headers: class Headers {
+          constructor() {}
+          entries() { return []; }
+        },
+        TextEncoder: class TextEncoder {
+          encode(text: string) {
+            return new Uint8Array(Array.from(text).map(c => c.charCodeAt(0)));
+          }
+        },
+        navigator: {
+          userAgent: 'test-agent'
+        },
+        Response: class Response {
+          constructor(public body: any, public init: any) {}
+          status: number = 200;
+          statusText: string = 'OK';
+          headers: any = {};
+        }
+      },
+      writable: true,
+    });
+  });
+
+  afterAll(() => {
+    Object.defineProperty(global, 'window', {
+      value: originalWindow,
+      writable: true,
+    });
+    global.fetch = originalFetch;
+  });
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    // Set up default behavior for listen
+    mockListen.mockImplementation(() => Promise.resolve(() => {}));
+  });
+
+  test('should use native fetch when Tauri is unavailable', async () => {
+    // Temporarily remove __TAURI__
+    const tempWindow = { ...window };
+    delete (tempWindow as any).__TAURI__;
+    Object.defineProperty(global, 'window', {
+      value: tempWindow,
+      writable: true,
+    });
+
+    await streamFetch('https://example.com');
+
+    // Check that native fetch was called
+    expect(window.fetch).toHaveBeenCalledWith('https://example.com', undefined);
+
+    // Restore __TAURI__
+    Object.defineProperty(global, 'window', {
+      value: { ...tempWindow, __TAURI__: true },
+      writable: true,
+    });
+  });
+
+  test('should use Tauri API when Tauri is available', async () => {
+    // Mock successful response from Tauri
+    // @ts-ignore
+    mockInvoke.mockResolvedValue({
+      request_id: 123,
+      status: 200,
+      status_text: 'OK',
+      headers: {}
+    } as any);
+
+    // Call fetch function
+    await streamFetch('https://example.com');
+
+    // Check that Tauri invoke was called with correct parameters
+    expect(mockInvoke).toHaveBeenCalledWith(
+      'stream_fetch',
+      expect.objectContaining({
+        url: 'https://example.com'
+      }),
+      undefined
+    );
+  });
+
+  test('should add abort signal to request', async () => {
+    // Mock successful response from Tauri
+    // @ts-ignore
+    mockInvoke.mockResolvedValue({
+      request_id: 123,
+      status: 200,
+      status_text: 'OK',
+      headers: {}
+    } as any);
+
+    // Create AbortController
+    const controller = new AbortController();
+    const addEventListenerSpy = jest.spyOn(controller.signal, 'addEventListener');
+
+    // Call fetch with signal
+    await streamFetch('https://example.com', {
+      signal: controller.signal
+    });
+
+    // Check that signal was added
+    expect(addEventListenerSpy).toHaveBeenCalledWith('abort', expect.any(Function));
+  });
+});