Squashed commit of the following:

commit 2a9f2f20e9c6d88c2f96fd40589740e1f236f64a
Author: Tunglies <77394545+Tunglies@users.noreply.github.com>
Date:   Mon Oct 13 11:07:31 2025 +0800

    fix: improve message handling in CommandEvent logging with CompactString

commit c77fc18accefeaf471594035d61bd13e235c87d6
Author: Tunglies <77394545+Tunglies@users.noreply.github.com>
Date:   Mon Oct 13 10:47:16 2025 +0800

    fix: optimize shared writer locking in CommandEvent handling

commit d5286ee5f1612f17b7a97eead84d430669816d98
Author: Tunglies <77394545+Tunglies@users.noreply.github.com>
Date:   Mon Oct 13 10:30:19 2025 +0800

    feat: integrate CompactString for improved logging and dependency management

commit 951fb2b120ce159c00dc57d43c5a519990f34cee
Author: Tunglies <77394545+Tunglies@users.noreply.github.com>
Date:   Mon Oct 13 09:39:29 2025 +0800

    refactor: remove write_sidecar_log function and streamline logging in CommandEvent handling

commit fd48d66c55a2c62fd32741fd3c65cc06d4cc693f
Author: Tunglies <77394545+Tunglies@users.noreply.github.com>
Date:   Mon Oct 13 09:38:05 2025 +0800

    Revert "refactor(core): stabilize 'static backing for sidecar logging"

    This reverts commit fe7eb59f18.

src-tauri/src/cmd/clash.rs

@@ -6,6 +6,7 @@ use crate::{
     core::{CoreManager, handle},
 };
 use crate::{config::*, feat, logging, utils::logging::Type, wrap_err};
+use compact_str::CompactString;
 use serde_yaml_ng::Mapping;
 
 /// 复制Clash环境变量
@@ -285,7 +286,7 @@ pub async fn validate_dns_config() -> CmdResult<(bool, String)> {
 }
 
 #[tauri::command]
-pub async fn get_clash_logs() -> CmdResult<VecDeque<String>> {
+pub async fn get_clash_logs() -> CmdResult<VecDeque<CompactString>> {
     let logs = CoreManager::global()
         .get_clash_logs()
         .await

src-tauri/src/core/core.rs

@@ -2,7 +2,7 @@ use crate::AsyncHandler;
 use crate::core::logger::ClashLogger;
 use crate::process::CommandChildGuard;
 use crate::utils::init::sidecar_writer;
-use crate::utils::logging::SharedWriter;
+use crate::utils::logging::{SharedWriter, write_sidecar_log};
 use crate::{
     config::*,
     core::{
@@ -17,9 +17,9 @@ use crate::{
     },
 };
 use anyhow::Result;
+use compact_str::CompactString;
 use flexi_logger::DeferredNow;
-use flexi_logger::writers::LogWriter;
-use log::Record;
+use log::Level;
 use parking_lot::Mutex;
 use std::collections::VecDeque;
 use std::{fmt, path::PathBuf, sync::Arc};
@@ -58,29 +58,6 @@ impl fmt::Display for RunningMode {
 
 use crate::config::IVerge;
 
-fn write_sidecar_log(
-    writer: &dyn LogWriter,
-    now: &mut DeferredNow,
-    level: log::Level,
-    message: String,
-) -> String {
-    let boxed = message.into_boxed_str();
-    let leaked: &'static mut str = Box::leak(boxed);
-    let leaked_ptr = leaked as *mut str;
-    {
-        let _ = writer.write(
-            now,
-            &Record::builder()
-                .args(format_args!("{}", &*leaked))
-                .level(level)
-                .target("sidecar")
-                .build(),
-        );
-    }
-    // SAFETY: `leaked` originated from `Box::leak` above; reboxing frees it immediately after use.
-    unsafe { String::from(Box::from_raw(leaked_ptr)) }
-}
-
 impl CoreManager {
     /// 检查文件是否为脚本文件
     fn is_script_file(&self, path: &str) -> Result<bool> {
@@ -767,30 +744,35 @@ impl CoreManager {
 
         AsyncHandler::spawn(|| async move {
             while let Some(event) = rx.recv().await {
-                let w = shared_writer.lock().await;
                 match event {
                     tauri_plugin_shell::process::CommandEvent::Stdout(line) => {
                         let mut now = DeferredNow::default();
-                        let message = String::from_utf8_lossy(&line).into_owned();
-                        let message = write_sidecar_log(&*w, &mut now, log::Level::Error, message);
+                        let message =
+                            CompactString::from(String::from_utf8_lossy(&line).into_owned());
+                        let w = shared_writer.lock().await;
+                        write_sidecar_log(w, &mut now, Level::Error, &message);
                         ClashLogger::global().append_log(message);
                     }
                     tauri_plugin_shell::process::CommandEvent::Stderr(line) => {
                         let mut now = DeferredNow::default();
-                        let message = String::from_utf8_lossy(&line).into_owned();
-                        let message = write_sidecar_log(&*w, &mut now, log::Level::Error, message);
+                        let message =
+                            CompactString::from(String::from_utf8_lossy(&line).into_owned());
+                        let w = shared_writer.lock().await;
+                        write_sidecar_log(w, &mut now, Level::Error, &message);
                         ClashLogger::global().append_log(message);
                     }
                     tauri_plugin_shell::process::CommandEvent::Terminated(term) => {
                         let mut now = DeferredNow::default();
                         let message = if let Some(code) = term.code {
-                            format!("Process terminated with code: {}", code)
+                            CompactString::from(format!("Process terminated with code: {}", code))
                         } else if let Some(signal) = term.signal {
-                            format!("Process terminated by signal: {}", signal)
+                            CompactString::from(format!("Process terminated by signal: {}", signal))
                         } else {
-                            "Process terminated".to_string()
+                            CompactString::from("Process terminated")
                         };
-                        write_sidecar_log(&*w, &mut now, log::Level::Info, message);
+                        let w = shared_writer.lock().await;
+                        write_sidecar_log(w, &mut now, Level::Info, &message);
+                        ClashLogger::global().clear_logs();
                         break;
                     }
                     _ => {}
@@ -899,10 +881,15 @@ impl CoreManager {
         Ok(())
     }
 
-    pub async fn get_clash_logs(&self) -> Result<VecDeque<String>> {
+    pub async fn get_clash_logs(&self) -> Result<VecDeque<CompactString>> {
         logging!(info, Type::Core, "get clash logs");
         let logs = match self.get_running_mode() {
-            RunningMode::Service => service::get_clash_logs_by_service().await?,
+            // TODO 服务端也完成 CompactString 迁移
+            RunningMode::Service => service::get_clash_logs_by_service()
+                .await?
+                .into_iter()
+                .map(CompactString::from)
+                .collect::<VecDeque<CompactString>>(),
             RunningMode::Sidecar => ClashLogger::global().get_logs().clone(),
             _ => VecDeque::new(),
         };

src-tauri/src/core/logger.rs

@@ -1,12 +1,13 @@
 use std::{collections::VecDeque, sync::Arc};
 
+use compact_str::CompactString;
 use once_cell::sync::OnceCell;
 use parking_lot::{RwLock, RwLockReadGuard};
 
 const LOGS_QUEUE_LEN: usize = 100;
 
 pub struct ClashLogger {
-    logs: Arc<RwLock<VecDeque<String>>>,
+    logs: Arc<RwLock<VecDeque<CompactString>>>,
 }
 
 impl ClashLogger {
@@ -18,11 +19,11 @@ impl ClashLogger {
         })
     }
 
-    pub fn get_logs(&self) -> RwLockReadGuard<'_, VecDeque<String>> {
+    pub fn get_logs(&self) -> RwLockReadGuard<'_, VecDeque<CompactString>> {
         self.logs.read()
     }
 
-    pub fn append_log(&self, text: String) {
+    pub fn append_log(&self, text: CompactString) {
         let mut logs = self.logs.write();
         if logs.len() > LOGS_QUEUE_LEN {
             logs.pop_front();

src-tauri/src/utils/logging.rs

@@ -1,10 +1,13 @@
+use compact_str::CompactString;
 use flexi_logger::writers::FileLogWriter;
+use flexi_logger::writers::LogWriter;
 #[cfg(not(feature = "tauri-dev"))]
 use flexi_logger::{DeferredNow, filter::LogLineFilter};
+use log::Level;
 #[cfg(not(feature = "tauri-dev"))]
 use log::Record;
 use std::{fmt, sync::Arc};
-use tokio::sync::Mutex;
+use tokio::sync::{Mutex, MutexGuard};
 
 pub type SharedWriter = Arc<Mutex<FileLogWriter>>;
 
@@ -134,6 +137,23 @@ macro_rules! logging_error {
     };
 }
 
+pub fn write_sidecar_log(
+    writer: MutexGuard<'_, FileLogWriter>,
+    now: &mut DeferredNow,
+    level: Level,
+    message: &CompactString,
+) {
+    let args = format_args!("{}", message);
+
+    let record = Record::builder()
+        .args(args)
+        .level(level)
+        .target("sidecar")
+        .build();
+
+    let _ = writer.write(now, &record);
+}
+
 #[cfg(not(feature = "tauri-dev"))]
 pub struct NoModuleFilter<'a>(pub &'a [&'a str]);