Migrate app from Tauri to Electron

Replace the Tauri/sidecar architecture with an Electron main process. Adds an electron/ directory (main, preload, handlers, core integrations for @xmcl/*), electron-builder.yml, TypeScript electron config and declarations, and updated IPC utilities (ipc.ts) so frontend uses ipcRenderer/ipcMain. Removes Tauri sidecar and src-tauri artifacts, deletes sidecar sources and keys, updates .gitignore, VSCode recommendations, package scripts and icons, and updates documentation (README, AGENTS, DEV) and frontend stores/apis to reflect the Electron-based architecture and config/auth persistence changes.

AGENTS.md

@@ -1,43 +1,56 @@
 # koring-launcher
 
-Minecraft launcher built with Tauri 2 + React 19 + TypeScript + Sidecar (Node.js/@xmcl).
+Minecraft launcher built with Electron + React 19 + TypeScript + Node.js (@xmcl).
 
 ## Quick commands
 
 ```bash
-pnpm tauri dev          # full app dev (frontend + Rust + sidecar skip)
-pnpm dev                # frontend only (vite, port 1420)
-cd sidecar && pnpm dev  # sidecar dev (tsx)
+pnpm dev                # full app dev (renderer + main process)
+pnpm dev:renderer       # frontend only (vite, port 1420)
+pnpm dev:main           # electron main process only
+pnpm build              # production build (vite + tsc)
+pnpm dist:win           # build Windows installer
 ```
 
 ## Architecture
 
 - **Frontend** (`src/`): React 19 + Vite 7 + Tailwind v4 + shadcn/ui + Zustand stores
-- **Backend** (`src-tauri/`): Rust/Tauri 2, manages sidecar process via stdin/stdout JSON
-- **Sidecar** (`sidecar/`): Node.js/TypeScript, wraps @xmcl/* packages (MC install/launch/auth/mods)
-- IPC: Frontend → `invoke()` → Rust commands → sidecar stdin → sidecar stdout → Tauri events → Frontend
+- **Main Process** (`electron/`): Node.js/TypeScript, manages windows, IPC handlers, @xmcl/* packages
+- IPC: Frontend → `ipcRenderer.invoke()` → `ipcMain.handle()` → main process → `webContents.send()` → Frontend
 
 ## Key gotchas
 
-- **Sidecar binary required**: `src-tauri/binaries/koring-sidecar-<target-triple>.exe` must exist. In debug mode it's skipped automatically (`#[cfg(debug_assertions)]` in `lib.rs:setup`).
-- **Sidecar compile**: `cd sidecar && pnpm compile` (requires `bun`). Default target is ARM64 Windows. Use `pnpm compile:x64` for x86_64.
-- **@xmcl packages are Node.js only**: `@xmcl/core`, `@xmcl/installer` require `fs`/`child_process`. Only `@xmcl/user`, `@xmcl/modrinth`, `@xmcl/curseforge` work in browser.
+- **Electron main process**: `electron/main.ts` is the entry point. All @xmcl/* packages run here.
+- **Preload script**: `electron/preload.ts` exposes `window.electronAPI` via context bridge.
+- **IPC handlers**: All handlers are in `electron/handlers/` directory.
+- **Config**: YAML format (`Koring.yml`) stored next to executable. Sparse save (only non-default values).
+- **Auth**: JSON file (`koring-auth.json`) stored next to executable.
 - **Path alias**: `@/` maps to `src/` (configured in `vite.config.ts` and `tsconfig.json`).
-- **Tauri commands**: All Rust commands are in `src-tauri/src/commands/mod.rs`. They forward to sidecar via `SidecarManager`.
-- **State management**: Zustand stores in `src/stores/` (install, auth, launch, mods, instance).
+- **Dev mode**: Vite runs on port 1420, Electron loads from localhost.
 
 ## Build & bundle
 
 ```bash
-pnpm tauri build         # production build (requires sidecar binary in binaries/)
-cd sidecar && pnpm compile  # compile sidecar to exe first
+pnpm build              # Vite build + TypeScript compile
+pnpm dist:win           # electron-builder Windows installer
+pnpm dist:mac           # electron-builder macOS DMG
+pnpm dist:linux         # electron-builder Linux AppImage
 ```
 
-The `externalBin` in `tauri.conf.json` expects `binaries/koring-sidecar-<target-triple>.exe`.
+## Electron notes
 
-## Rust notes
+- `electron/main.ts`: App entry, window management, IPC handler registration
+- `electron/preload.ts`: Context bridge for secure IPC
+- `electron/config.ts`: YAML config management (sparse save)
+- `electron/auth.ts`: Auth data persistence (JSON file)
+- `electron/core/`: @xmcl/* integrations (auth, installer, launcher, modrinth, instance)
+- `electron/handlers/`: IPC handlers (config, auth, install, launch, mods, instance, background, task, system, window)
 
-- `src-tauri/src/lib.rs`: app entry, registers plugins and commands
-- `src-tauri/src/sidecar.rs`: `SidecarManager` — spawns sidecar, reads stdout, emits Tauri events
-- `src-tauri/src/commands/mod.rs`: all `#[tauri::command]` handlers
-- `uuid` crate used for request IDs
+## Frontend notes
+
+- `src/api/ipc.ts`: Core IPC utilities (invoke, onIpcEvent)
+- `src/api/*.ts`: API modules wrapping IPC calls
+- `src/stores/`: Zustand state management
+- `src/hooks/useTheme.ts`: Dark mode sync with Electron theme
+- `src/components/system/WindowControls.tsx`: Custom window controls (min/max/close)
+- `src/components/system/TitleBar.tsx`: Custom title bar with navigation