feat(desktop): Sidecar 健康度面板 + 重启后端能力

P1 已经把 backend-warning / backend-terminated 横幅做出来了；P2 把
lib.rs 那条 stdout/stderr/terminated 信息流真正落到一个常驻 UI 上：
- 右下角浮动状态点（绿/黄/红），轮询 /api/sys_health 决定颜色
- 点开抽屉看最近 200 行日志（ring buffer），含「重启后端」「复制日志」按钮

Rust：
- src-tauri/src/lib.rs：把 sidecar 启动抽出 spawn_backend_sidecar()，
  CommandChild 存进 SidecarHandle(Mutex<Option<CommandChild>>) 这个 state
- 新增 #[tauri::command] restart_backend_sidecar：kill 旧 child + 重新 spawn +
  emit 'backend-restarted' 给前端
- 监听任务 stdout/stderr emit 时不再用 format!("'{}'", ...) 包引号，原文直传；
  前端 hook 同时兼容旧形式（兜底剥引号）

前端：
- components/BackendHealth/useBackendEvents.ts：listen 四个事件 +
  ring buffer (MAX 200 行) + invoke restart + clipboard 复制日志
- BackendHealthIndicator.tsx：右下角浮动状态点，5s 轮询 /api/sys_health；
  连续 3 次失败或 backend-terminated 触发 → 红
- BackendLogPanel.tsx：右侧抽屉，深色 monospace 日志区 + 操作按钮
- 纯 web 环境（无 __TAURI_INTERNALS__）下静默不挂载

P3 / P4 还在路上。

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

BillNote_frontend/src-tauri/src/lib.rs

@@ -1,11 +1,15 @@
-use tauri::{Manager, Emitter};
+use tauri::{Manager, Emitter, State};
 use tauri_plugin_shell::ShellExt;
-use tauri_plugin_shell::process::CommandEvent;
+use tauri_plugin_shell::process::{CommandChild, CommandEvent};
 use std::env;
 use std::collections::HashMap;
 use std::path::Path;
+use std::sync::Mutex;
 use serde::Serialize;
 
+// Sidecar 子进程句柄，用 Mutex 包裹方便 restart 时杀旧进程
+struct SidecarHandle(Mutex<Option<CommandChild>>);
+
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
     tauri::Builder::default()
@@ -20,7 +24,6 @@ pub fn run() {
             }
 
             let exe_path = env::current_exe().expect("无法获取当前可执行文件路径");
-            let sidecar_dir = exe_path.parent().expect("无法获取可执行文件的父目录");
 
             // 安装路径诊断：PyInstaller sidecar 在含非 ASCII / 空格的路径下经常炸（README 已警告但缺主动防御）
             // 命中时把诊断信息 emit 给前端，由顶端横幅展示，不阻断启动
@@ -37,75 +40,15 @@ pub fn run() {
                 });
             }
 
-            // 收集所有系统环境变量
-            let mut all_env_vars = HashMap::new();
-            for (key, value) in env::vars() {
-                all_env_vars.insert(key, value);
-            }
-
-            // 增强 PATH 环境变量，添加常见的二进制路径
-            let current_path = all_env_vars.get("PATH").cloned().unwrap_or_default();
-            let additional_paths = get_additional_binary_paths();
-            let enhanced_path = enhance_path_variable(&current_path, &additional_paths);
-            all_env_vars.insert("PATH".to_string(), enhanced_path);
-
-            // 打印一些关键环境变量用于调试
-            println!("Enhanced PATH: {}", all_env_vars.get("PATH").unwrap_or(&"Not found".to_string()));
-            println!("Total environment variables: {}", all_env_vars.len());
-
             // 检查 ffmpeg 是否在 PATH 中可用
             check_ffmpeg_availability();
 
-            // 启动 Python 后端侧车
-            let mut sidecar_command = app.shell().sidecar("BiliNoteBackend").unwrap();
-
-            // 设置所有环境变量到 sidecar
-            for (key, value) in &all_env_vars {
-                sidecar_command = sidecar_command.env(key, value);
-            }
-
-            let (mut rx, _child) = sidecar_command
-                .current_dir(sidecar_dir)
-                .spawn()
-                .expect("Failed to spawn sidecar");
-
-            // 获取主窗口句柄用于发送事件
-            let window = app.get_webview_window("main").unwrap();
-
-            tauri::async_runtime::spawn(async move {
-                // 读取诸如 stdout 之类的事件
-                while let Some(event) = rx.recv().await {
-                    match event {
-                        CommandEvent::Stdout(line) => {
-                            let output = String::from_utf8_lossy(&line);
-                            println!("Backend stdout: {}", output);
-
-                            // 发送到前端
-                            window
-                                .emit("backend-message", Some(format!("'{}'", output)))
-                                .expect("failed to emit event");
-                        }
-                        CommandEvent::Stderr(line) => {
-                            let error = String::from_utf8_lossy(&line);
-                            eprintln!("Backend stderr: {}", error);
-
-                            window
-                                .emit("backend-error", Some(format!("'{}'", error)))
-                                .expect("failed to emit event");
-                        }
-                        CommandEvent::Terminated(payload) => {
-                            println!("Backend terminated with code: {:?}", payload.code);
-                            window
-                                .emit("backend-terminated", Some(payload.code))
-                                .expect("failed to emit event");
-                            break;
-                        }
-                        _ => {
-                            println!("Backend event: {:?}", event);
-                        }
-                    }
-                }
-            });
+            // 启动 Sidecar 并把 child handle 存到 state，方便后续 restart_backend_sidecar 使用
+            let child = spawn_backend_sidecar(app.handle()).map_err(|e| {
+                eprintln!("Sidecar 启动失败: {}", e);
+                e
+            })?;
+            app.manage(SidecarHandle(Mutex::new(Some(child))));
 
             Ok(())
         })
@@ -114,7 +57,8 @@ pub fn run() {
             find_executable_path,
             run_command_with_env,
             test_ffmpeg_access,
-            get_install_path_diagnostics
+            get_install_path_diagnostics,
+            restart_backend_sidecar
         ])
         .run(tauri::generate_context!())
         .expect("error while running tauri application");
@@ -286,6 +230,102 @@ async fn test_ffmpeg_access() -> Result<String, String> {
     run_command_with_env("ffmpeg".to_string(), vec!["-version".to_string()]).await
 }
 
+// 启动后端 Sidecar：负责装环境变量、spawn、挂 stdout/stderr/terminated 监听并 emit 给前端。
+// 第一次启动 + restart_backend_sidecar 都走这里，保持单一启动路径。
+fn spawn_backend_sidecar(app_handle: &tauri::AppHandle) -> Result<CommandChild, String> {
+    let exe_path = env::current_exe().map_err(|e| format!("无法获取可执行文件路径: {}", e))?;
+    let sidecar_dir = exe_path
+        .parent()
+        .ok_or("无法获取可执行文件父目录")?
+        .to_path_buf();
+
+    // 收集所有系统环境变量并增强 PATH（含 ffmpeg 常见安装位置）
+    let mut all_env_vars = HashMap::new();
+    for (key, value) in env::vars() {
+        all_env_vars.insert(key, value);
+    }
+    let current_path = all_env_vars.get("PATH").cloned().unwrap_or_default();
+    let additional_paths = get_additional_binary_paths();
+    let enhanced_path = enhance_path_variable(&current_path, &additional_paths);
+    all_env_vars.insert("PATH".to_string(), enhanced_path);
+
+    let mut sidecar_command = app_handle
+        .shell()
+        .sidecar("BiliNoteBackend")
+        .map_err(|e| format!("找不到 BiliNoteBackend sidecar: {}", e))?;
+    for (key, value) in &all_env_vars {
+        sidecar_command = sidecar_command.env(key, value);
+    }
+
+    let (mut rx, child) = sidecar_command
+        .current_dir(sidecar_dir)
+        .spawn()
+        .map_err(|e| format!("spawn sidecar 失败: {}", e))?;
+
+    // 异步监听 stdout / stderr / terminated 事件，转发到前端 webview
+    let app_handle_for_listener = app_handle.clone();
+    tauri::async_runtime::spawn(async move {
+        while let Some(event) = rx.recv().await {
+            // window 句柄每次重新取，允许窗口关闭重开
+            let window = app_handle_for_listener.get_webview_window("main");
+            match event {
+                CommandEvent::Stdout(line) => {
+                    let output = String::from_utf8_lossy(&line).to_string();
+                    println!("Backend stdout: {}", output);
+                    if let Some(w) = window {
+                        let _ = w.emit("backend-message", Some(output));
+                    }
+                }
+                CommandEvent::Stderr(line) => {
+                    let error = String::from_utf8_lossy(&line).to_string();
+                    eprintln!("Backend stderr: {}", error);
+                    if let Some(w) = window {
+                        let _ = w.emit("backend-error", Some(error));
+                    }
+                }
+                CommandEvent::Terminated(payload) => {
+                    println!("Backend terminated with code: {:?}", payload.code);
+                    if let Some(w) = window {
+                        let _ = w.emit("backend-terminated", Some(payload.code));
+                    }
+                    break;
+                }
+                _ => {
+                    println!("Backend event: {:?}", event);
+                }
+            }
+        }
+    });
+
+    Ok(child)
+}
+
+// 重启 sidecar：杀旧 child，spawn 新 child，回写到 state。
+#[tauri::command]
+fn restart_backend_sidecar(
+    state: State<'_, SidecarHandle>,
+    app: tauri::AppHandle,
+) -> Result<(), String> {
+    // 1. 拿出旧 child 并 kill（kill 失败也继续，可能进程已经退了）
+    {
+        let mut guard = state.0.lock().map_err(|e| format!("锁 sidecar state 失败: {}", e))?;
+        if let Some(child) = guard.take() {
+            let _ = child.kill();
+        }
+    }
+    // 2. 重新 spawn
+    let new_child = spawn_backend_sidecar(&app)?;
+    {
+        let mut guard = state.0.lock().map_err(|e| format!("锁 sidecar state 失败: {}", e))?;
+        *guard = Some(new_child);
+    }
+    // 3. emit 一个事件让前端知道已重启
+    if let Some(window) = app.get_webview_window("main") {
+        let _ = window.emit("backend-restarted", ());
+    }
+    Ok(())
+}
+
 // 安装路径诊断：PyInstaller 在含非 ASCII / 空格的路径下加载 _internal/* 经常炸；
 // 父目录不可写时模型 / 配置 / 日志也无法落盘
 #[derive(Serialize, Clone)]