feat(remote): add built-in remote management HTTP server

Motivation
----------
Switching AI providers currently requires opening the desktop CC Switch
app. When working on a headless machine or wanting to switch from a
phone, there is no way to do so without a separate script that bypasses
the app's state management, causing race conditions.

Approach
--------
Add a lightweight Axum HTTP server embedded in the Tauri desktop app.
The server provides a mobile-friendly Web UI and REST API for provider
switching, directly calling ProviderService::switch() to ensure backfill
and state consistency.

Backend (Rust):
- remote/mod.rs: RemoteServer with start/stop lifecycle, SSE broadcast
  channel, and Tailscale IP detection (resolves binary from known paths
  to avoid macOS GUI app PATH limitations).
- remote/handlers.rs: 7 Axum endpoints — HTML page, provider list,
  switch, current, SSE events, health check, and icon with dynamic SVG
  coloring.
- remote/html.rs: Embedded single-page dark-theme HTML UI with
  EventSource for real-time SSE updates.
- commands/remote.rs: Tauri commands for start/stop server, check
  Tailscale availability, and query Tailscale IP.
- Integration points in lib.rs (startup), tray.rs, provider.rs,
  failover.rs, failover_switch.rs to broadcast SSE on provider switch.

Frontend (React):
- RemoteSettings.tsx: Settings UI with enable toggle (immediate
  start/stop), port input (stops server on change, user re-enables to
  apply), Tailscale toggle with pre-flight availability check (disabled
  when server is off), Tailscale IP display, and live status indicator.
- i18n translations for en/zh/ja.

Result
------
Users can now switch providers from any browser on the local network.
Default: http://localhost:4000. With Tailscale enabled, accessible from
mobile devices at the displayed Tailscale URL. Server is fully
manageable from the settings page without app restart.
17 files changed, +1172 -1 lines.

Author: Yongmao Luo

src-tauri/src/commands/failover.rs

@@ -158,6 +158,8 @@ pub async fn set_auto_failover_enabled(
             "source": "failoverEnabled"
         });
         let _ = app.emit("provider-switched", event_data);
+        // 广播给远程浏览器（SSE）
+        crate::remote::broadcast_provider_switch(&app, &app_type, &p1_provider_id);
     }
 
     // 刷新托盘菜单，确保状态同步

src-tauri/src/commands/mod.rs

@@ -20,6 +20,7 @@ mod plugin;
 mod prompt;
 mod provider;
 mod proxy;
+pub(crate) mod remote;
 mod session_manager;
 mod settings;
 pub mod skill;

src-tauri/src/commands/provider.rs

@@ -100,12 +100,19 @@ pub fn switch_provider_test_hook(
 
 #[tauri::command]
 pub fn switch_provider(
+    app_handle: tauri::AppHandle,
     state: State<'_, AppState>,
     app: String,
     id: String,
 ) -> Result<SwitchResult, String> {
     let app_type = AppType::from_str(&app).map_err(|e| e.to_string())?;
-    switch_provider_internal(&state, app_type, &id).map_err(|e| e.to_string())
+    let result =
+        switch_provider_internal(&state, app_type.clone(), &id).map_err(|e| e.to_string())?;
+
+    // 广播给远程浏览器（SSE）
+    crate::remote::broadcast_provider_switch(&app_handle, app_type.as_str(), &id);
+
+    Ok(result)
 }
 
 fn import_default_config_internal(state: &AppState, app_type: AppType) -> Result<bool, AppError> {

src-tauri/src/commands/remote.rs

@@ -0,0 +1,30 @@
+use tauri::{command, AppHandle};
+
+#[command]
+pub async fn start_remote_server(app: AppHandle) -> Result<String, String> {
+    let settings = crate::settings::get_settings();
+    let config = crate::remote::RemoteConfig {
+        enabled: true,
+        port: settings.remote_port,
+        tailscale_enabled: settings.remote_tailscale_enabled,
+    };
+
+    let urls = crate::remote::start_remote(&app, config).await?;
+    Ok(format!("Remote server started on: {}", urls.join(", ")))
+}
+
+#[command]
+pub async fn stop_remote_server(app: AppHandle) -> Result<String, String> {
+    crate::remote::stop_remote(&app).await?;
+    Ok("Remote server stopped".to_string())
+}
+
+#[command]
+pub fn check_tailscale_available() -> bool {
+    crate::remote::is_tailscale_available()
+}
+
+#[command]
+pub fn get_tailscale_ip() -> Option<String> {
+    crate::remote::get_tailscale_ip()
+}

src-tauri/src/lib.rs

@@ -24,6 +24,7 @@ mod prompt_files;
 mod provider;
 mod provider_defaults;
 mod proxy;
+mod remote;
 mod services;
 mod session_manager;
 mod settings;
@@ -770,6 +771,42 @@ pub fn run() {
             // 将同一个实例注入到全局状态，避免重复创建导致的不一致
             app.manage(app_state);
 
+            // 启动 Remote Management HTTP Server
+            {
+                let app_settings = crate::settings::get_settings();
+                let remote_config = remote::RemoteConfig {
+                    enabled: app_settings.remote_enabled,
+                    port: app_settings.remote_port,
+                    tailscale_enabled: app_settings.remote_tailscale_enabled,
+                };
+
+                let remote_server = remote::RemoteServer::new(
+                    app.handle().clone(),
+                    remote_config.clone(),
+                );
+
+                // 注入 RemoteServer 供 Tauri 命令使用
+                app.manage(remote::ManagedRemoteServer(Arc::new(tokio::sync::RwLock::new(Some(remote_server)))));
+
+                // 异步启动 remote server（仅当 enabled 时）
+                if remote_config.enabled {
+                    let managed = app.state::<remote::ManagedRemoteServer>();
+                    let guard = managed.0.clone();
+                    let _ = &managed;
+                    tauri::async_runtime::spawn(async move {
+                        let read_guard = guard.read().await;
+                        if let Some(ref server) = *read_guard {
+                            match server.start().await {
+                                Ok(urls) => log::info!("[Remote] Management server started on: {}", urls.join(", ")),
+                                Err(e) => log::warn!("[Remote] Failed to start management server: {e}"),
+                            }
+                        }
+                    });
+                } else {
+                    log::info!("[Remote] Remote management server disabled");
+                }
+            }
+
             // 从数据库加载日志配置并应用
             {
                 let db = &app.state::<AppState>().db;
@@ -1116,6 +1153,11 @@ pub fn run() {
             commands::import_from_deeplink,
             commands::import_from_deeplink_unified,
             update_tray_menu,
+            // Remote management
+            commands::remote::start_remote_server,
+            commands::remote::stop_remote_server,
+            commands::remote::check_tailscale_available,
+            commands::remote::get_tailscale_ip,
             // Environment variable management
             commands::check_env_conflicts,
             commands::delete_env_vars,

src-tauri/src/proxy/failover_switch.rs

@@ -128,6 +128,8 @@ impl FailoverSwitchManager {
             if let Err(e) = app.emit("provider-switched", event_data) {
                 log::error!("[Failover] 发射事件失败: {e}");
             }
+            // 广播给远程浏览器（SSE）
+            crate::remote::broadcast_provider_switch(app, app_type, provider_id);
         }
 
         Ok(switched)