I've integrated the Rust backend for process management and API proxy-

DEPLOYMENT.md

@@ -0,0 +1,87 @@
+# Deployment Guide: Running Amica Locally
+
+This guide provides step-by-step instructions for setting up and running the Rust-powered version of Amica on your local machine.
+
+## 1. Prerequisites
+
+Before you begin, you need to have the following software installed on your system:
+
+*   **Node.js:** Amica's user interface is built with Node.js. You will need version `18.18.0` or newer. You can download it from the [official Node.js website](https://nodejs.org/).
+*   **Rust:** The new backend is written in Rust. The easiest way to install Rust is by using `rustup`. You can find instructions at the [official Rust website](https://www.rust-lang.org/tools/install).
+*   **`text-generation-webui`:** You must have a working, pre-compiled version of `text-generation-webui`. You can find releases and setup instructions on its [GitHub repository](https://github.com/oobabooga/text-generation-webui). Make sure you can run it successfully on its own before integrating it with Amica.
+*   **(Linux Only) Build Dependencies:** On Linux, you will need to install a few extra packages for Tauri to build correctly. You can install them with the following command:
+    ```bash
+    sudo apt-get update
+    sudo apt-get install -y libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libayatana-appindicator3-dev librsvg2-dev
+    ```
+
+## 2. Installation and Configuration
+
+Follow these steps to get the Amica project set up.
+
+#### Step 1: Clone the Amica Repository
+
+Open your terminal, navigate to where you want to store the project, and run the following command:
+
+```bash
+git clone https://github.com/semperai/amica
+cd amica
+```
+
+#### Step 2: Install JavaScript Dependencies
+
+Once you are in the `amica` directory, run this command to install all the necessary frontend packages:
+
+```bash
+npm install
+```
+
+#### Step 3: Configure the `text-generation-webui` Path
+
+The application needs to know where to find your `text-generation-webui` executable.
+
+1.  Find the `settings.json` file in the root of the `amica` directory.
+2.  Open it and you will see:
+    ```json
+    {
+      "text_generation_webui_path": ""
+    }
+    ```
+3.  Add the **full path** to your executable inside the quotes.
+
+    *   **Windows Example:**
+        ```json
+        {
+          "text_generation_webui_path": "C:\\Users\\YourUser\\Desktop\\text-generation-webui\\start.bat"
+        }
+        ```
+        *(Note the double backslashes `\\`)*
+
+    *   **Linux/macOS Example:**
+        ```json
+        {
+          "text_generation_webui_path": "/home/youruser/text-generation-webui/start.sh"
+        }
+        ```
+
+## 3. Building the Application
+
+Now that everything is configured, you can build the final, standalone executable.
+
+Run the following command in your terminal. This process will compile the Rust backend and package it with the frontend into a single application. It may take several minutes.
+
+```bash
+npm run tauri build
+```
+
+Once the build is complete, you will find the final application inside the `src-tauri/target/release/` directory. It will be a `.exe` file on Windows, a `.AppImage` on Linux, or a `.app` file inside a `.dmg` on macOS.
+
+## 4. Running Amica
+
+You can now run this executable file directly! There is no need for any further commands.
+
+On the first run, be sure to open the in-app settings and configure the following:
+*   **Chatbot Backend:** Select **KoboldAI**.
+*   **Streaming/Extra Option:** If you see an option for streaming, make sure it is **disabled**.
+
+That's it! Your self-contained, Rust-powered Amica application is now ready to use.

settings.json

@@ -0,0 +1,3 @@
+{
+  "text_generation_webui_path": ""
+}

src-tauri/Cargo.toml

@@ -18,6 +18,8 @@ tauri-build = { version = "1.5.5", features = [] }
 serde_json = "1.0.128"
 serde = { version = "1.0.210", features = ["derive"] }
 tauri = { version = "1.8.0", features = [ "macos-private-api", "system-tray", "shell-open"] }
+reqwest = { version = "0.12.5", features = ["json"] }
+tokio = { version = "1.39.2", features = ["full"] }
 
 [features]
 # this feature is used for production builds or when `devPath` points to the filesystem and the built-in dev server is disabled.

src-tauri/src/main.rs

@@ -2,52 +2,176 @@
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
 
 use tauri::{
-  CustomMenuItem,
-  SystemTray,
-  SystemTrayEvent,
-  SystemTrayMenu,
-  SystemTrayMenuItem,
+  api::process::{Command, CommandEvent},
+  CustomMenuItem, Manager, SystemTray, SystemTrayEvent, SystemTrayMenu, SystemTrayMenuItem,
 };
-use tauri::Manager;
+use std::sync::Mutex;
+use std::fs;
+
+#[derive(serde::Deserialize, Clone)]
+struct Settings {
+    text_generation_webui_path: String,
+}
+
+// the payload type must implement `Serialize` and `Clone`.
+#[derive(Clone, serde::Serialize)]
+struct Payload {
+  message: String,
+}
+
+struct AppState {
+    child_process: Mutex<Option<tauri::api::process::Child>>,
+}
 
 #[tauri::command]
 async fn close_splashscreen(window: tauri::Window) {
   // Close splashscreen
-  window.get_window("splashscreen").expect("no window labeled 'splashscreen' found").close().unwrap();
+  if let Some(splashscreen) = window.get_window("splashscreen") {
+    splashscreen.close().unwrap();
+  }
   // Show main window
-  window.get_window("main").expect("no window labeled 'main' found").show().unwrap();
+  window.get_window("main").unwrap().show().unwrap();
+}
+
+#[derive(serde::Deserialize)]
+struct ProxyRequestPayload {
+    path: String,
+    body: serde_json::Value,
 }
 
+#[tauri::command]
+async fn proxy_request(payload: ProxyRequestPayload) -> Result<serde_json::Value, String> {
+    let client = reqwest::Client::new();
+    // This port should be configurable in the future.
+    let url = format!("http://127.0.0.1:5000/{}", payload.path);
+
+    let res = client
+        .post(&url)
+        .json(&payload.body)
+        .send()
+        .await
+        .map_err(|e| e.to_string())?;
+
+    if res.status().is_success() {
+        res.json::<serde_json::Value>()
+            .await
+            .map_err(|e| e.to_string())
+    } else {
+        let status = res.status();
+        let text = res.text().await.map_err(|e| e.to_string())?;
+        Err(format!(
+            "API request to {} failed with status {}: {}",
+            url, status, text
+        ))
+    }
+}
 
 fn main() {
-  tauri::Builder::default()
-    .system_tray(SystemTray::new()
-      .with_menu(SystemTrayMenu::new()
-        .add_item(CustomMenuItem::new("checkforupdates".to_string(), "Check for updates"))
-        .add_native_item(SystemTrayMenuItem::Separator)
-        .add_item(CustomMenuItem::new("help".to_string(), "Help"))
-        .add_native_item(SystemTrayMenuItem::Separator)
-        .add_item(CustomMenuItem::new("quit".to_string(), "Quit"))
-      )
-    )
-    .on_system_tray_event(|app, event| match event {
-      SystemTrayEvent::MenuItemClick { id, .. } => {
-        match id.as_str() {
-          "quit" => {
-            std::process::exit(0);
-          }
-          "checkforupdates" => {
-            tauri::api::shell::open(&app.shell_scope(), "https://github.com/semperai/amica/releases/latest", None).expect("failed to open url");
-          }
-          "help" => {
-            tauri::api::shell::open(&app.shell_scope(), "https://docs.heyamica.com", None).expect("failed to open url");
-          }
-          _ => {}
-        }
-      }
-      _ => {}
-    })
-    .invoke_handler(tauri::generate_handler![close_splashscreen])
-    .run(tauri::generate_context!())
-    .expect("error while running tauri application");
+    let app_state = AppState {
+        child_process: Mutex::new(None),
+    };
+
+    tauri::Builder::default()
+        .manage(app_state)
+        .setup(|app| {
+            let handle = app.handle();
+            let app_state = handle.state::<AppState>();
+
+            // Read settings
+            let settings_path = "settings.json";
+            let settings_str = fs::read_to_string(settings_path)
+                .expect("Failed to read settings.json");
+            let settings: Settings = serde_json::from_str(&settings_str)
+                .expect("Failed to parse settings.json");
+
+            if settings.text_generation_webui_path.is_empty() {
+                // In a real app, you'd want to show a dialog to the user
+                panic!("text_generation_webui_path is not set in settings.json");
+            }
+
+            // Launch the external process
+            tauri::async_runtime::spawn(async move {
+                let (mut rx, child) = Command::new(settings.text_generation_webui_path)
+                    .spawn()
+                    .expect("Failed to spawn external process");
+
+                *app_state.child_process.lock().unwrap() = Some(child);
+
+                while let Some(event) = rx.recv().await {
+                    if let CommandEvent::Stdout(line) = event {
+                        // Here you can log the output from the sidecar
+                        // Or send it to the frontend
+                        handle
+                            .emit_all("sidecar-output", Payload { message: line.into() })
+                            .unwrap();
+                    }
+                }
+            });
+
+            Ok(())
+        })
+        .system_tray(
+            SystemTray::new().with_menu(
+                SystemTrayMenu::new()
+                    .add_item(CustomMenuItem::new("checkforupdates".to_string(), "Check for updates"))
+                    .add_native_item(SystemTrayMenuItem::Separator)
+                    .add_item(CustomMenuItem::new("help".to_string(), "Help"))
+                    .add_native_item(SystemTrayMenuItem::Separator)
+                    .add_item(CustomMenuItem::new("quit".to_string(), "Quit")),
+            ),
+        )
+        .on_system_tray_event(|app, event| match event {
+            SystemTrayEvent::MenuItemClick { id, .. } => match id.as_str() {
+                "quit" => {
+                    let app_handle = app.app_handle();
+                    let app_state = app_handle.state::<AppState>();
+                    if let Some(child) = app_state.child_process.lock().unwrap().take() {
+                        child.kill().expect("Failed to kill sidecar");
+                    }
+                    app_handle.exit(0);
+                }
+                "checkforupdates" => {
+                    tauri::api::shell::open(
+                        &app.shell_scope(),
+                        "https://github.com/semperai/amica/releases/latest",
+                        None,
+                    )
+                    .expect("failed to open url");
+                }
+                "help" => {
+                    tauri::api::shell::open(
+                        &app.shell_scope(),
+                        "https://docs.heyamica.com",
+                        None,
+                    )
+                    .expect("failed to open url");
+                }
+                _ => {}
+            },
+            _ => {}
+        })
+        .on_window_event(|event| {
+            if let tauri::WindowEvent::CloseRequested { api, .. } = event.event() {
+                let app_handle = event.window().app_handle();
+                let app_state = app_handle.state::<AppState>();
+                if let Some(child) = app_state.child_process.lock().unwrap().take() {
+                    child.kill().expect("Failed to kill sidecar");
+                }
+                app_handle.exit(0);
+            }
+        })
+        .invoke_handler(tauri::generate_handler![
+            close_splashscreen,
+            proxy_request
+        ])
+        .build(tauri::generate_context!())
+        .expect("error while building tauri application")
+        .run(|app_handle, event| {
+            if let tauri::RunEvent::ExitRequested { .. } = event {
+                let app_state = app_handle.state::<AppState>();
+                if let Some(child) = app_state.child_process.lock().unwrap().take() {
+                    child.kill().expect("Failed to kill sidecar");
+                }
+            }
+        });
 }

src-tauri/tauri.conf.json

@@ -14,7 +14,18 @@
     "allowlist": {
       "all": false,
       "shell": {
+        "all": false,
         "open": true
+      },
+      "http": {
+        "all": false,
+        "request": true,
+        "scope": [
+          "http://127.0.0.1:*/*",
+          "https://127.0.0.1:*/*",
+          "http://localhost:*/*",
+          "https://localhost:*/*"
+        ]
       }
     },
     "bundle": {

src/features/chat/koboldAiChat.ts

@@ -1,6 +1,7 @@
 import { Message } from "./messages";
 import { buildPrompt } from "@/utils/buildPrompt";
 import { config } from '@/utils/config';
+import { invoke } from "@tauri-apps/api/tauri";
 
 export async function getKoboldAiChatResponseStream(messages: Message[]) {
   if (config("koboldai_use_extra") === 'true') {
@@ -79,23 +80,21 @@ async function getExtra(messages: Message[]) {
 
 // koboldai / no stream support
 async function getNormal(messages: Message[]) {
-  const headers: Record<string, string> = {
-    "Content-Type": "application/json",
-  };
-
   const prompt = buildPrompt(messages);
   const stop_sequence: string[] = [`${config("name")}:`, ...`${config("koboldai_stop_sequence")}`.split("||")];
 
-  const res = await fetch(`${config("koboldai_url")}/api/v1/generate`, {
-    headers: headers,
-    method: "POST",
-    body: JSON.stringify({
-      prompt,
-      stop_sequence
-    }),
+  const body = {
+    prompt,
+    stop_sequence,
+  };
+
+  const json: any = await invoke("proxy_request", {
+    payload: {
+      path: "api/v1/generate",
+      body: body,
+    },
   });
 
-  const json = await res.json();
   if (json.results.length === 0) {
     throw new Error(`KoboldAi result length 0`);
   }