node build fixed

seanime-2.9.10/seanime-desktop/.gitignore

@@ -0,0 +1,3 @@
+node_modules
+.idea
+.run

seanime-2.9.10/seanime-desktop/README.md

@@ -0,0 +1,139 @@
+<p align="center">
+<img src="../seanime-web/public/logo_2.png" alt="preview" width="150px"/>
+</p>
+
+<h2 align="center"><b>Seanime Desktop</b></h2>
+
+<p align="center">
+Desktop app for Seanime. Embeds server and web interface.
+</p>
+
+<img src="../docs/images/4/anime-entry-torrent-stream--sq.jpg" alt="preview" width="100%"/>
+
+---
+
+## Prerequisites
+
+- Go 1.24+
+- Node.js 20+ and npm
+- Rust 1.75+
+
+---
+
+## Development
+
+### Web Interface
+
+```shell
+# Working dir: ./seanime-web
+npm run dev:desktop
+```
+ 
+### Sidecar
+
+1. Build the server
+
+	```shell
+	# Working dir: .
+ 
+	# Windows
+	go build -o seanime.exe -trimpath -ldflags="-s -w" -tags=nosystray
+ 
+	# Linux, macOS
+	go build -o seanime -trimpath -ldflags="-s -w"
+	```
+ 
+2. Move the binary to `./seanime-desktop/src-tauri/binaries`
+
+3. Rename the binary to `seanime-{TARGET_TRIPLE}`. [Reference](https://v2.tauri.app/develop/sidecar/).
+
+	- `seanime-x86_64-pc-windows-msvc.exe` for Windows
+    - `seanime-x86_64-unknown-linux-musl` for Linux
+    - `seanime-x86_64-apple-darwin` for macOS (Intel-based)
+    - `seanime-aarch64-apple-darwin` for macOS (Apple Silicon)
+
+### Tauri
+
+1. Setup
+
+	```shell
+	# Working dir: ./seanime-desktop
+	npm install
+	```
+2. Run
+
+    `TEST_DATADIR` is needed when running in development mode, it should point to a dummy data directory for Seanime.
+
+    ```shell
+    # Working dir: ./seanime-desktop
+    TEST_DATADIR="/path/to/data/dir" npm run start
+	# or
+	TEST_DATADIR="/path/to/data/dir" tauri dev
+   ```
+
+---
+
+## Build
+
+### Web Interface
+
+- **Option A:**
+   
+	Uses `.env.desktop` and outputs to `./seanime-web/out-desktop`
+
+	```shell
+	# Working dir: ./seanime-web
+	npm run build:desktop
+	```
+ 
+	Move the output to `./web-desktop`
+
+	```shell
+	# UNIX command
+	mv ./seanime-web/out-desktop ./web-desktop
+	```
+ 
+- **Option B:**
+	
+   Uses `.env.development.desktop` and outputs to `./web-desktop`
+		
+	```shell
+	# Working dir: ./seanime-web
+	npm run build:development:desktop
+	```
+
+### Sidecar
+
+1. Build the server
+
+	```shell
+	# Working dir: .
+ 
+	# Windows
+	go build -o seanime.exe -trimpath -ldflags="-s -w" -tags=nosystray
+ 
+	# Linux, macOS
+	go build -o seanime -trimpath -ldflags="-s -w"
+	```
+ 
+2. Move the binary to `./seanime-desktop/src-tauri/binaries`
+
+3. Rename the binary to `seanime-{TARGET_TRIPLE}`. [Reference](https://v2.tauri.app/develop/sidecar/).
+
+	- `seanime-x86_64-pc-windows-msvc.exe` for Windows
+    - `seanime-x86_64-unknown-linux-musl` for Linux
+    - `seanime-x86_64-apple-darwin` for macOS (Intel-based)
+    - `seanime-aarch64-apple-darwin` for macOS (Apple Silicon)
+
+### Tauri
+
+Set the signing private key and password. [Reference](https://v2.tauri.app/plugin/updater/#signing-updates).
+- `TAURI_SIGNING_PRIVATE_KEY`
+- `TAURI_SIGNING_PRIVATE_KEY_PASSWORD`
+
+```shell
+# Working dir: ./seanime-desktop
+TAURI_SIGNING_PRIVATE_KEY="" TAURI_SIGNING_PRIVATE_KEY_PASSWORD="" npm run tauri build
+```
+
+Output is in `./seanime-desktop/src-tauri/target/release/bundle/...`

seanime-2.9.10/seanime-desktop/package-lock.json

@@ -0,0 +1,231 @@
+{
+  "name": "seanime-desktop",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "seanime-desktop",
+      "version": "1.0.0",
+      "dependencies": {
+        "@tauri-apps/api": "^2.4.1",
+        "@tauri-apps/cli": "^2.4.1"
+      }
+    },
+    "node_modules/@tauri-apps/api": {
+      "version": "2.4.1",
+      "resolved": "https://registry.npmjs.org/@tauri-apps/api/-/api-2.4.1.tgz",
+      "integrity": "sha512-5sYwZCSJb6PBGbBL4kt7CnE5HHbBqwH+ovmOW6ZVju3nX4E3JX6tt2kRklFEH7xMOIwR0btRkZktuLhKvyEQYg==",
+      "license": "Apache-2.0 OR MIT",
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/tauri"
+      }
+    },
+    "node_modules/@tauri-apps/cli": {
+      "version": "2.4.1",
+      "resolved": "https://registry.npmjs.org/@tauri-apps/cli/-/cli-2.4.1.tgz",
+      "integrity": "sha512-9Ta81jx9+57FhtU/mPIckDcOBtPTUdKM75t4+aA0X84b8Sclb0jy1xA8NplmcRzp2fsfIHNngU2NiRxsW5+yOQ==",
+      "license": "Apache-2.0 OR MIT",
+      "bin": {
+        "tauri": "tauri.js"
+      },
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/tauri"
+      },
+      "optionalDependencies": {
+        "@tauri-apps/cli-darwin-arm64": "2.4.1",
+        "@tauri-apps/cli-darwin-x64": "2.4.1",
+        "@tauri-apps/cli-linux-arm-gnueabihf": "2.4.1",
+        "@tauri-apps/cli-linux-arm64-gnu": "2.4.1",
+        "@tauri-apps/cli-linux-arm64-musl": "2.4.1",
+        "@tauri-apps/cli-linux-riscv64-gnu": "2.4.1",
+        "@tauri-apps/cli-linux-x64-gnu": "2.4.1",
+        "@tauri-apps/cli-linux-x64-musl": "2.4.1",
+        "@tauri-apps/cli-win32-arm64-msvc": "2.4.1",
+        "@tauri-apps/cli-win32-ia32-msvc": "2.4.1",
+        "@tauri-apps/cli-win32-x64-msvc": "2.4.1"
+      }
+    },
+    "node_modules/@tauri-apps/cli-darwin-arm64": {
+      "version": "2.4.1",
+      "resolved": "https://registry.npmjs.org/@tauri-apps/cli-darwin-arm64/-/cli-darwin-arm64-2.4.1.tgz",
+      "integrity": "sha512-QME7s8XQwy3LWClTVlIlwXVSLKkeJ/z88pr917Mtn9spYOjnBfsgHAgGdmpWD3NfJxjg7CtLbhH49DxoFL+hLg==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "Apache-2.0 OR MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@tauri-apps/cli-darwin-x64": {
+      "version": "2.4.1",
+      "resolved": "https://registry.npmjs.org/@tauri-apps/cli-darwin-x64/-/cli-darwin-x64-2.4.1.tgz",
+      "integrity": "sha512-/r89IcW6Ya1sEsFUEH7wLNruDTj7WmDWKGpPy7gATFtQr5JEY4heernqE82isjTUimnHZD8SCr0jA3NceI4ybw==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "Apache-2.0 OR MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@tauri-apps/cli-linux-arm-gnueabihf": {
+      "version": "2.4.1",
+      "resolved": "https://registry.npmjs.org/@tauri-apps/cli-linux-arm-gnueabihf/-/cli-linux-arm-gnueabihf-2.4.1.tgz",
+      "integrity": "sha512-9tDijkRB+CchAGjXxYdY9l/XzFpLp1yihUtGXJz9eh+3qIoRI043n3e+6xmU8ZURr7XPnu+R4sCmXs6HD+NCEQ==",
+      "cpu": [
+        "arm"
+      ],
+      "license": "Apache-2.0 OR MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@tauri-apps/cli-linux-arm64-gnu": {
+      "version": "2.4.1",
+      "resolved": "https://registry.npmjs.org/@tauri-apps/cli-linux-arm64-gnu/-/cli-linux-arm64-gnu-2.4.1.tgz",
+      "integrity": "sha512-pnFGDEXBAzS4iDYAVxTRhAzNu3K2XPGflYyBc0czfHDBXopqRgMyj5Q9Wj7HAwv6cM8BqzXINxnb2ZJFGmbSgA==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "Apache-2.0 OR MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@tauri-apps/cli-linux-arm64-musl": {
+      "version": "2.4.1",
+      "resolved": "https://registry.npmjs.org/@tauri-apps/cli-linux-arm64-musl/-/cli-linux-arm64-musl-2.4.1.tgz",
+      "integrity": "sha512-Hp0zXgeZNKmT+eoJSCxSBUm2QndNuRxR55tmIeNm3vbyUMJN/49uW7nurZ5fBPsacN4Pzwlx1dIMK+Gnr9A69w==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "Apache-2.0 OR MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@tauri-apps/cli-linux-riscv64-gnu": {
+      "version": "2.4.1",
+      "resolved": "https://registry.npmjs.org/@tauri-apps/cli-linux-riscv64-gnu/-/cli-linux-riscv64-gnu-2.4.1.tgz",
+      "integrity": "sha512-3T3bo2E4fdYRvzcXheWUeQOVB+LunEEi92iPRgOyuSVexVE4cmHYl+MPJF+EUV28Et0hIVTsHibmDO0/04lAFg==",
+      "cpu": [
+        "riscv64"
+      ],
+      "license": "Apache-2.0 OR MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@tauri-apps/cli-linux-x64-gnu": {
+      "version": "2.4.1",
+      "resolved": "https://registry.npmjs.org/@tauri-apps/cli-linux-x64-gnu/-/cli-linux-x64-gnu-2.4.1.tgz",
+      "integrity": "sha512-kLN0FdNONO+2i+OpU9+mm6oTGufRC00e197TtwjpC0N6K2K8130w7Q3FeODIM2CMyg0ov3tH+QWqKW7GNhHFzg==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "Apache-2.0 OR MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@tauri-apps/cli-linux-x64-musl": {
+      "version": "2.4.1",
+      "resolved": "https://registry.npmjs.org/@tauri-apps/cli-linux-x64-musl/-/cli-linux-x64-musl-2.4.1.tgz",
+      "integrity": "sha512-a8exvA5Ub9eg66a6hsMQKJIkf63QAf9OdiuFKOsEnKZkNN2x0NLgfvEcqdw88VY0UMs9dBoZ1AGbWMeYnLrLwQ==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "Apache-2.0 OR MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@tauri-apps/cli-win32-arm64-msvc": {
+      "version": "2.4.1",
+      "resolved": "https://registry.npmjs.org/@tauri-apps/cli-win32-arm64-msvc/-/cli-win32-arm64-msvc-2.4.1.tgz",
+      "integrity": "sha512-4JFrslsMCJQG1c573T9uqQSAbF3j/tMKkMWzsIssv8jvPiP++OG61A2/F+y9te9/Q/O95cKhDK63kaiO5xQaeg==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "Apache-2.0 OR MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@tauri-apps/cli-win32-ia32-msvc": {
+      "version": "2.4.1",
+      "resolved": "https://registry.npmjs.org/@tauri-apps/cli-win32-ia32-msvc/-/cli-win32-ia32-msvc-2.4.1.tgz",
+      "integrity": "sha512-9eXfFORehYSCRwxg2KodfmX/mhr50CI7wyBYGbPLePCjr5z0jK/9IyW6r0tC+ZVjwpX48dkk7hKiUgI25jHjzA==",
+      "cpu": [
+        "ia32"
+      ],
+      "license": "Apache-2.0 OR MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@tauri-apps/cli-win32-x64-msvc": {
+      "version": "2.4.1",
+      "resolved": "https://registry.npmjs.org/@tauri-apps/cli-win32-x64-msvc/-/cli-win32-x64-msvc-2.4.1.tgz",
+      "integrity": "sha512-60a4Ov7Jrwqz2hzDltlS7301dhSAmM9dxo+IRBD3xz7yobKrgaHXYpWvnRomYItHcDd51VaKc9292H8/eE/gsw==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "Apache-2.0 OR MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    }
+  }
+}

seanime-2.9.10/seanime-desktop/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "seanime-desktop",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "start": "tauri dev",
+    "build": "tauri build",
+    "tauri": "tauri"
+  },
+  "dependencies": {
+    "@tauri-apps/api": "^2.4.1",
+    "@tauri-apps/cli": "^2.4.1"
+  },
+  "private": true
+}

seanime-2.9.10/seanime-desktop/src-tauri/.gitignore

@@ -0,0 +1,8 @@
+.idea
+# Generated by Cargo
+# will have compiled files and executables
+/target/
+/gen/schemas
+# Sidecar binaries
+/binaries/*.exe
+/binaries/seanime-aarch64-apple-darwin

seanime-2.9.10/seanime-desktop/src-tauri/Cargo.toml

@@ -0,0 +1,33 @@
+[package]
+name = "seanime-desktop"
+version = "0.1.0"
+description = "Seanime Desktop"
+authors = ["you"]
+license = ""
+repository = ""
+edition = "2021"
+rust-version = "1.71"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[lib]
+name = "app_lib"
+crate-type = ["staticlib", "cdylib", "lib"]
+
+[build-dependencies]
+tauri-build = { version = "2.1.1", features = [] }
+
+[dependencies]
+serde_json = "1.0"
+serde = { version = "1.0", features = ["derive"] }
+tauri = { version = "2.4.1", features = ["macos-private-api", "tray-icon", "devtools"] }
+tauri-plugin-shell = "2.2.1"
+strip-ansi-escapes = "0.2.1"
+tokio = "1.43.0"
+tauri-plugin-decorum = "1.1.1"
+tauri-plugin-os = "2.2.1"
+tauri-plugin-clipboard-manager = "2.2.2"
+
+[target.'cfg(not(any(target_os = "android", target_os = "ios")))'.dependencies]
+tauri-plugin-single-instance = "2"
+tauri-plugin-updater = "2.4.0"

seanime-2.9.10/seanime-desktop/src-tauri/build.rs

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

seanime-2.9.10/seanime-desktop/src-tauri/capabilities/desktop.json

@@ -0,0 +1,15 @@
+{
+  "identifier": "desktop-capability",
+  "platforms": [
+    "macOS",
+    "windows",
+    "linux"
+  ],
+  "permissions": [
+    "updater:default",
+    "updater:allow-check",
+    "updater:allow-download",
+    "updater:allow-download-and-install",
+    "updater:allow-install"
+  ]
+}

seanime-2.9.10/seanime-desktop/src-tauri/capabilities/main.json

@@ -0,0 +1,92 @@
+{
+  "$schema": "../gen/schemas/desktop-schema.json",
+  "identifier": "default",
+  "description": "enables the default permissions",
+  "windows": [
+    "main",
+    "splashscreen",
+    "crash_screen"
+  ],
+  "permissions": [
+    "os:allow-arch",
+    "os:allow-hostname",
+    "os:allow-os-type",
+    "core:path:default",
+    "core:event:default",
+    "core:window:default",
+    "core:app:default",
+    "core:image:default",
+    "core:resources:default",
+    "core:menu:default",
+    "core:tray:default",
+    "shell:allow-open",
+    "shell:default",
+    "core:window:allow-set-title-bar-style",
+    "core:window:allow-center",
+    "core:window:allow-request-user-attention",
+    "core:window:allow-set-resizable",
+    "core:window:allow-set-maximizable",
+    "core:window:allow-set-minimizable",
+    "core:window:allow-set-closable",
+    "core:window:allow-set-title",
+    "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-decorations",
+    "core:window:allow-set-shadow",
+    "core:window:allow-set-effects",
+    "core:window:allow-set-always-on-top",
+    "core:window:allow-set-always-on-bottom",
+    "core:window:allow-set-content-protected",
+    "core:window:allow-set-size",
+    "core:window:allow-set-min-size",
+    "core:window:allow-set-max-size",
+    "core:window:allow-set-position",
+    "core:window:allow-set-fullscreen",
+    "core:window:allow-set-focus",
+    "core:window:allow-set-skip-taskbar",
+    "core:window:allow-set-cursor-grab",
+    "core:window:allow-set-cursor-visible",
+    "core:window:allow-set-cursor-icon",
+    "core:window:allow-set-cursor-position",
+    "core:window:allow-set-ignore-cursor-events",
+    "core:window:allow-start-dragging",
+    "core:window:allow-set-progress-bar",
+    "core:window:allow-set-icon",
+    "core:window:allow-toggle-maximize",
+    "core:webview:allow-create-webview-window",
+    "core:webview:allow-print",
+    "updater:default",
+    "updater:allow-check",
+    "updater:allow-download",
+    "updater:allow-download-and-install",
+    "updater:allow-install",
+    "clipboard-manager:allow-clear",
+    "clipboard-manager:allow-write-text",
+    "clipboard-manager:allow-write-html",
+    "clipboard-manager:allow-write-image",
+    "clipboard-manager:allow-read-text",
+    "clipboard-manager:allow-read-image",
+    {
+      "identifier": "shell:allow-execute",
+      "allow": [
+        {
+          "args": [
+            "-desktop-sidecar",
+            "true",
+            "-datadir",
+            {
+              "validator": "[\\S+ ]"
+            }
+          ],
+          "name": "binaries/seanime",
+          "sidecar": true
+        }
+      ]
+    }
+  ]
+}

seanime-2.9.10/seanime-desktop/src-tauri/src/constants.rs

@@ -0,0 +1,3 @@
+pub const MAIN_WINDOW_LABEL: &str = "main";
+pub const SPLASHSCREEN_WINDOW_LABEL: &str = "splashscreen";
+pub const CRASH_SCREEN_WINDOW_LABEL: &str = "crash_screen";

seanime-2.9.10/seanime-desktop/src-tauri/src/lib.rs

@@ -0,0 +1,193 @@
+mod constants;
+mod server;
+#[cfg(desktop)]
+mod tray;
+
+use constants::MAIN_WINDOW_LABEL;
+use std::sync::{Arc, Mutex};
+#[cfg(target_os = "macos")]
+use tauri::utils::TitleBarStyle;
+use tauri::{Emitter, Listener, Manager};
+use tauri_plugin_os;
+
+pub fn run() {
+    let server_process = Arc::new(Mutex::new(
+        None::<tauri_plugin_shell::process::CommandChild>,
+    ));
+    let server_process_for_setup = Arc::clone(&server_process);
+    let server_process_for_restart = Arc::clone(&server_process);
+    //
+    let is_shutdown = Arc::new(Mutex::new(false));
+    let is_shutdown_for_setup = Arc::clone(&is_shutdown);
+    let is_shutdown_for_restart = Arc::clone(&is_shutdown);
+
+    let server_started = Arc::new(Mutex::new(false));
+    let server_started_for_setup = Arc::clone(&server_started);
+    let server_started_for_restart = Arc::clone(&server_started);
+
+    tauri::Builder::default()
+        .plugin(tauri_plugin_single_instance::init(|app, _cmd, _args| {
+            if let Some(window) = app.get_webview_window(MAIN_WINDOW_LABEL) {
+                window.show().unwrap();
+                window.set_focus().unwrap();
+            }
+        }))
+        .plugin(tauri_plugin_updater::Builder::new().build())
+        .plugin(tauri_plugin_shell::init())
+        .plugin(tauri_plugin_os::init())
+        .plugin(tauri_plugin_clipboard_manager::init())
+        .setup(move |app| {
+            #[cfg(all(desktop))]
+            {
+                let handle = app.handle();
+                tray::create_tray(handle)?;
+            }
+
+            let main_window = app.get_webview_window(MAIN_WINDOW_LABEL).unwrap();
+            main_window.hide().unwrap();
+
+            // Set overlay title bar only when building for macOS
+            #[cfg(target_os = "macos")]
+            main_window
+                .set_title_bar_style(TitleBarStyle::Overlay)
+                .unwrap();
+
+            // Hide the title bar on Windows
+            #[cfg(any(target_os = "windows"))]
+            main_window.set_decorations(false).unwrap();
+
+            // Open dev tools only when in dev mode
+            #[cfg(debug_assertions)]
+            {
+                main_window.open_devtools();
+            }
+
+            server::launch_seanime_server(
+                app.handle().clone(),
+                server_process_for_setup,
+                is_shutdown_for_setup,
+                server_started_for_setup,
+            );
+
+            let app_handle = app.handle().clone();
+            app.listen("restart-server", move |_| {
+                println!("EVENT restart-server");
+                let mut child_guard = server_process_for_restart.lock().unwrap();
+                if let Some(child) = child_guard.take() {
+                    println!("Killing existing server process");
+                    // Kill the existing server process
+                    if let Err(e) = child.kill() {
+                        eprintln!("Failed to kill server process: {}", e);
+                    }
+                }
+                server::launch_seanime_server(
+                    app_handle.clone(),
+                    Arc::clone(&server_process_for_restart),
+                    Arc::clone(&is_shutdown_for_restart),
+                    Arc::clone(&server_started_for_restart),
+                );
+            });
+
+            let app_handle_1 = app.handle().clone();
+            let main_window_clone = main_window.clone();
+            main_window.listen("macos-activation-policy-accessory", move |_| {
+                println!("EVENT macos-activation-policy-accessory");
+                #[cfg(target_os = "macos")]
+                {
+                    if let Err(e) = app_handle_1.set_activation_policy(tauri::ActivationPolicy::Accessory) {
+                        eprintln!("Failed to set activation policy to accessory: {}", e);
+                    } else {
+                        if let Err(e) = main_window_clone.show() {
+                            eprintln!("Failed to show main window: {}", e);
+                        }
+                        if let Err(e) = main_window_clone.set_fullscreen(true) {
+                            eprintln!("Failed to set fullscreen: {}", e);
+                        } else {
+                            std::thread::sleep(std::time::Duration::from_millis(150));
+                            if let Err(e) = main_window_clone.set_focus() {
+                                eprintln!("Failed to set focus after fullscreen: {}", e);
+                            }
+                            main_window_clone.emit("macos-activation-policy-accessory-done", "").unwrap();
+                        }
+                    }
+                }
+            });
+
+            // main_window.on_window_event()
+
+            let app_handle_2 = app.handle().clone();
+            main_window.listen("macos-activation-policy-regular", move |_| {
+                println!("EVENT macos-activation-policy-regular");
+                #[cfg(target_os = "macos")]
+                app_handle_2
+                    .set_activation_policy(tauri::ActivationPolicy::Regular)
+                    .unwrap();
+            });
+
+            Ok(())
+        })
+        .build(tauri::generate_context!())
+        .expect("error while running tauri application")
+        .run({
+            let server_process_for_exit = Arc::clone(&server_process);
+            let is_shutdown_for_exit = Arc::clone(&is_shutdown);
+            move |app, event| {
+                let server_process_for_exit_ = Arc::clone(&server_process);
+                app.listen("kill-server", move |_| {
+                    let mut child_guard = server_process_for_exit_.lock().unwrap();
+                    if let Some(child) = child_guard.take() {
+                        // Kill server process
+                        if let Err(e) = child.kill() {
+                            eprintln!("Failed to kill server process: {}", e);
+                        }
+                    }
+                });
+
+                match event {
+                    tauri::RunEvent::WindowEvent {
+                        label,
+                        event: tauri::WindowEvent::CloseRequested { api, .. },
+                        ..
+                    } => {
+                        let is_shutdown_guard = is_shutdown_for_exit.lock().unwrap();
+                        if label.as_str() == MAIN_WINDOW_LABEL && !*is_shutdown_guard {
+                            println!("Main window close request");
+                            // Hide the window when user clicks 'X'
+                            let win = app.get_webview_window(label.as_str()).unwrap();
+                            win.hide().unwrap();
+                            // Prevent the window from being closed
+                            api.prevent_close();
+                            #[cfg(target_os = "macos")]
+                            app.set_activation_policy(tauri::ActivationPolicy::Accessory)
+                                .unwrap();
+                        }
+                    }
+
+                    // tauri::RunEvent::Exit => {
+                    //     let mut child_guard = server_process_for_exit.lock().unwrap();
+                    //     if let Some(child) = child_guard.take() {
+                    //         // Kill server process
+                    //         if let Err(e) = child.kill() {
+                    //             eprintln!("Failed to kill server process: {}", e);
+                    //         }
+                    //     }
+                    // }
+
+                    // The app is about to exit
+                    tauri::RunEvent::ExitRequested { .. } => {
+                        println!("Main window exit request");
+                        let mut child_guard = server_process_for_exit.lock().unwrap();
+                        if let Some(child) = child_guard.take() {
+                            // Kill server process
+                            if let Err(e) = child.kill() {
+                                eprintln!("Failed to kill server process: {}", e);
+                            }
+                        }
+                    }
+                    _ => {}
+                }
+            }
+        });
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

seanime-2.9.10/seanime-desktop/src-tauri/src/main.rs

@@ -0,0 +1,12 @@
+// Prevents additional console window on Windows in release, DO NOT REMOVE!!
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
+
+fn main() {
+    #[cfg(target_os = "linux")]
+    {
+        std::env::set_var("WEBKIT_DISABLE_COMPOSITING_MODE", "1");
+    }
+
+
+    app_lib::run();
+}

seanime-2.9.10/seanime-desktop/src-tauri/src/server.rs

@@ -0,0 +1,116 @@
+use crate::constants::{CRASH_SCREEN_WINDOW_LABEL, MAIN_WINDOW_LABEL, SPLASHSCREEN_WINDOW_LABEL};
+use std::sync::{Arc, Mutex};
+use strip_ansi_escapes;
+use tauri::{AppHandle, Emitter, Manager};
+use tauri_plugin_shell::process::CommandEvent;
+use tauri_plugin_shell::ShellExt;
+use tokio::time::{sleep, Duration};
+
+pub fn launch_seanime_server(
+    app: AppHandle,
+    child_process: Arc<Mutex<Option<tauri_plugin_shell::process::CommandChild>>>,
+    is_shutdown: Arc<Mutex<bool>>,
+    server_started: Arc<Mutex<bool>>,
+) {
+    tauri::async_runtime::spawn(async move {
+        let main_window = app.get_webview_window(MAIN_WINDOW_LABEL).unwrap();
+        // let splashscreen = app.get_webview_window(SPLASHSCREEN_WINDOW_LABEL).unwrap();
+        // let crash_screen = app.get_webview_window(CRASH_SCREEN_WINDOW_LABEL).unwrap();
+
+        let mut sidecar_command = app.shell().sidecar("seanime").unwrap();
+
+        // Use test data dir during development
+        #[cfg(dev)]
+        {
+            sidecar_command = sidecar_command.args(["-datadir", env!("TEST_DATADIR")]);
+        }
+
+        sidecar_command = sidecar_command.args(["-desktop-sidecar", "true"]);
+
+
+        let (mut rx, child) = match sidecar_command.spawn() {
+            Ok(result) => result,
+            Err(e) => {
+                // Seanime server failed to open -> close splashscreen and display crash screen
+                if let Some(splashscreen) = app.get_webview_window(SPLASHSCREEN_WINDOW_LABEL) {
+                    splashscreen.close().unwrap();
+                }
+                if let Some(crash_screen) = app.get_webview_window(CRASH_SCREEN_WINDOW_LABEL) {
+                    crash_screen.show().unwrap();
+                }
+                app.emit(
+                    "crash",
+                    format!("The server failed to start: {}. Closing in 10 seconds.", e),
+                )
+                    .expect("failed to emit event");
+                sleep(Duration::from_secs(10)).await;
+                std::process::exit(1);
+            }
+        };
+
+        // Store the child process
+        *child_process.lock().unwrap() = Some(child);
+
+        // let mut server_started = false;
+
+        // Read server terminal output
+        while let Some(event) = rx.recv().await {
+            match event {
+                CommandEvent::Stdout(line) => {
+                    let line_without_colors = strip_ansi_escapes::strip(line);
+                    match String::from_utf8(line_without_colors) {
+                        Ok(line_str) => {
+                            if !server_started.lock().unwrap().clone() {
+                                if line_str.contains("Client connected") {
+                                    sleep(Duration::from_secs(2)).await;
+
+                                    *server_started.lock().unwrap() = true;
+                                    if let Some(splashscreen) = app.get_webview_window(SPLASHSCREEN_WINDOW_LABEL) {
+                                        splashscreen.close().unwrap();
+                                    }
+                                    main_window.maximize().unwrap();
+                                    main_window.show().unwrap();
+                                }
+                            }
+                            // Emit the line to the main window
+                            main_window
+                                .emit("message", Some(format!("{}", line_str)))
+                                .expect("failed to emit event");
+
+                            println!("{}", line_str);
+                        }
+                        Err(_) => {}
+                    }
+                }
+                CommandEvent::Terminated(status) => {
+                    eprintln!(
+                        "Seanime server process terminated with status: {:?} {:?}",
+                        status, server_started.lock().unwrap()
+                    );
+                    *is_shutdown.lock().unwrap() = true;
+                    // Only terminate the app if the desktop app hadn't launched
+                    if !server_started.lock().unwrap().clone() {
+                        if let Some(splashscreen) = app.get_webview_window(SPLASHSCREEN_WINDOW_LABEL) {
+                            splashscreen.close().unwrap();
+                        }
+                        #[cfg(debug_assertions)]
+                        {
+                            main_window.close_devtools();
+                        }
+                        main_window.close().unwrap();
+                        if let Some(crash_screen) = app.get_webview_window(CRASH_SCREEN_WINDOW_LABEL) {
+                            crash_screen.show().unwrap();
+                        }
+
+                        app.emit("crash", format!("Seanime server process terminated with status: {}. Closing in 10 seconds.", status.code.unwrap_or(1))).expect("failed to emit event");
+
+                        sleep(Duration::from_secs(10)).await;
+                        app.exit(1);
+                    }
+                    break;
+                }
+                _ => {}
+            }
+        }
+    });
+}

seanime-2.9.10/seanime-desktop/src-tauri/src/tray.rs

@@ -0,0 +1,102 @@
+use crate::constants::MAIN_WINDOW_LABEL;
+use tauri::{
+    menu::{Menu, MenuItem},
+    tray::{MouseButton, MouseButtonState, TrayIconBuilder, TrayIconEvent},
+    Manager, Runtime,
+};
+
+pub fn create_tray<R: Runtime>(app: &tauri::AppHandle<R>) -> tauri::Result<()> {
+    let quit_i = MenuItem::with_id(app, "quit", "Quit Seanime", true, None::<&str>)?;
+    // let restart_i = MenuItem::with_id(app, "restart", "Restart Seanime", true, None::<&str>)?;
+    // let open_web_i = MenuItem::with_id(app, "open_web", "Open Web UI", true, None::<&str>)?;
+    let toggle_visibility_i = MenuItem::with_id(
+        app,
+        "toggle_visibility",
+        "Toggle visibility",
+        true,
+        None::<&str>,
+    )?;
+    let accessory_mode_i = MenuItem::with_id(
+        app,
+        "accessory_mode",
+        "Remove from dock",
+        true,
+        None::<&str>,
+    )?;
+    let mut items: Vec<&dyn tauri::menu::IsMenuItem<R>> = vec![&toggle_visibility_i, &quit_i];
+
+    #[cfg(target_os = "macos")]
+    {
+        items = vec![&toggle_visibility_i, &accessory_mode_i, &quit_i];
+    }
+
+    let menu = Menu::with_items(app, &items)?;
+
+    let _ = TrayIconBuilder::with_id("tray")
+        .icon(app.default_window_icon().unwrap().clone())
+        .menu(&menu)
+        .menu_on_left_click(false)
+        .on_menu_event(move |app, event| match event.id.as_ref() {
+            "quit" => {
+                app.exit(0);
+            }
+            // "restart" => app.restart(),
+            "toggle_visibility" => {
+                if let Some(window) = app.get_webview_window(MAIN_WINDOW_LABEL) {
+                    if !window.is_visible().unwrap() {
+                        let _ = window.show();
+                        let _ = window.set_focus();
+                        #[cfg(target_os = "macos")]
+                        app.set_activation_policy(tauri::ActivationPolicy::Regular)
+                            .unwrap();
+                    } else {
+                        let _ = window.hide();
+                        #[cfg(target_os = "macos")]
+                        app.set_activation_policy(tauri::ActivationPolicy::Accessory)
+                            .unwrap();
+                    }
+                }
+            }
+            "accessory_mode" => {
+                #[cfg(target_os = "macos")]
+                app.set_activation_policy(tauri::ActivationPolicy::Accessory)
+                    .unwrap();
+            }
+            // "hide" => {
+            //     if let Some(window) = app.get_webview_window(MAIN_WINDOW_LABEL) {
+            //         if window.is_minimized().unwrap() {
+            //             let _ = window.show();
+            //             let _ = window.set_focus();
+            //             #[cfg(target_os = "macos")]
+            //             app.set_activation_policy(tauri::ActivationPolicy::Regular).unwrap();
+            //         } else {
+            //             let _ = window.hide();
+            //             #[cfg(target_os = "macos")]
+            //             app.set_activation_policy(tauri::ActivationPolicy::Accessory).unwrap();
+            //         }
+            //     }
+            // }
+            // Add more events here
+            _ => {}
+        })
+        .on_tray_icon_event(|tray, event| {
+            if let TrayIconEvent::Click {
+                button: MouseButton::Left,
+                button_state: MouseButtonState::Up,
+                ..
+            } = event
+            {
+                let app = tray.app_handle();
+                if let Some(window) = app.get_webview_window(MAIN_WINDOW_LABEL) {
+                    let _ = window.show();
+                    let _ = window.set_focus();
+                    #[cfg(target_os = "macos")]
+                    app.set_activation_policy(tauri::ActivationPolicy::Regular)
+                        .unwrap();
+                }
+            }
+        })
+        .build(app);
+
+    Ok(())
+}

seanime-2.9.10/seanime-desktop/src-tauri/tauri.conf.json

@@ -0,0 +1,89 @@
+{
+  "productName": "Seanime Desktop",
+  "version": "2.9.10",
+  "identifier": "app.seanime.desktop",
+  "build": {
+    "frontendDist": "../../web-desktop",
+    "devUrl": "http://127.0.0.1:43210"
+  },
+  "app": {
+    "withGlobalTauri": true,
+    "macOSPrivateApi": true,
+    "windows": [
+      {
+        "label": "main",
+        "title": "Seanime",
+        "width": 800,
+        "height": 600,
+        "resizable": true,
+        "fullscreen": false,
+        "visible": false,
+        "hiddenTitle": true
+      },
+      {
+        "label": "splashscreen",
+        "title": "Seanime",
+        "width": 800,
+        "height": 600,
+        "resizable": false,
+        "decorations": false,
+        "url": "/splashscreen",
+        "hiddenTitle": true
+      },
+      {
+        "label": "crash_screen",
+        "title": "Seanime",
+        "width": 800,
+        "height": 600,
+        "resizable": false,
+        "decorations": false,
+        "url": "/splashscreen/crash",
+        "hiddenTitle": true,
+        "visible": false
+      }
+    ],
+    "security": {
+      "csp": null
+    }
+  },
+  "plugins": {
+    "updater": {
+      "pubkey": "dW50cnVzdGVkIGNvbW1lbnQ6IG1pbmlzaWduIHB1YmxpYyBrZXk6IDg4Q0RFQTc5NTQyRDU4RDYKUldUV1dDMVVlZXJOaU8xMlBhbU1xNG1IY2lLVG1oMXBnWm81VTNKem11N3EzcWk4NHI0SXhtbGkK",
+      "endpoints": [
+        "https://github.com/5rahim/seanime/releases/latest/download/latest.json"
+      ]
+    }
+  },
+  "bundle": {
+    "active": true,
+    "createUpdaterArtifacts": true,
+    "targets": [
+      "appimage",
+      "nsis",
+      "app"
+    ],
+    "icon": [
+      "icons/32x32.png",
+      "icons/128x128.png",
+      "icons/128x128@2x.png",
+      "icons/icon.icns",
+      "icons/icon.ico"
+    ],
+    "linux": {
+      "appimage": {
+        "bundleMediaFramework": true
+      }
+    },
+    "windows": {
+      "nsis": {
+        "minimumWebview2Version": "110.0.1531.0"
+      }
+    },
+    "macOS": {
+      "signingIdentity": "-"
+    },
+    "externalBin": [
+      "binaries/seanime"
+    ]
+  }
+}