From 2a7ccb5bde3bc7d05342fd775cbd93c7a6201a8c Mon Sep 17 00:00:00 2001
From: Tunglies <77394545+Tunglies@users.noreply.github.com>
Date: Tue, 28 Oct 2025 19:16:42 +0800
Subject: [PATCH] refactor(core): optimize RunningMode handling and improve
 state management

---
 src-tauri/src/core/manager/lifecycle.rs |  4 ++--
 src-tauri/src/core/manager/mod.rs       | 16 ++++++++++------
 src-tauri/src/core/manager/state.rs     | 19 ++++++++++---------
 src-tauri/src/utils/logging.rs          |  2 +-
 4 files changed, 23 insertions(+), 18 deletions(-)

diff --git a/src-tauri/src/core/manager/lifecycle.rs b/src-tauri/src/core/manager/lifecycle.rs
index 4dfbae88..90c2fcfd 100644
--- a/src-tauri/src/core/manager/lifecycle.rs
+++ b/src-tauri/src/core/manager/lifecycle.rs
@@ -14,7 +14,7 @@ impl CoreManager {
     pub async fn start_core(&self) -> Result<()> {
         self.prepare_startup().await?;
 
-        match self.get_running_mode() {
+        match *self.get_running_mode() {
             RunningMode::Service => self.start_core_by_service().await,
             RunningMode::NotRunning | RunningMode::Sidecar => self.start_core_by_sidecar().await,
         }
@@ -23,7 +23,7 @@ impl CoreManager {
     pub async fn stop_core(&self) -> Result<()> {
         ClashLogger::global().clear_logs();
 
-        match self.get_running_mode() {
+        match *self.get_running_mode() {
             RunningMode::Service => self.stop_core_by_service().await,
             RunningMode::Sidecar => self.stop_core_by_sidecar(),
             RunningMode::NotRunning => Ok(()),
diff --git a/src-tauri/src/core/manager/mod.rs b/src-tauri/src/core/manager/mod.rs
index 88d5cdb7..4ef122ae 100644
--- a/src-tauri/src/core/manager/mod.rs
+++ b/src-tauri/src/core/manager/mod.rs
@@ -11,7 +11,7 @@ use tokio::sync::Semaphore;
 use crate::process::CommandChildGuard;
 use crate::singleton_lazy;
 
-#[derive(Debug, Clone, Copy, serde::Serialize, PartialEq, Eq)]
+#[derive(Debug, serde::Serialize, PartialEq, Eq)]
 pub enum RunningMode {
     Service,
     Sidecar,
@@ -37,14 +37,14 @@ pub struct CoreManager {
 
 #[derive(Debug)]
 struct State {
-    running_mode: RunningMode,
+    running_mode: Arc<RunningMode>,
     child_sidecar: Option<CommandChildGuard>,
 }
 
 impl Default for State {
     fn default() -> Self {
         Self {
-            running_mode: RunningMode::NotRunning,
+            running_mode: Arc::new(RunningMode::NotRunning),
             child_sidecar: None,
         }
     }
@@ -61,12 +61,16 @@ impl Default for CoreManager {
 }
 
 impl CoreManager {
-    pub fn get_running_mode(&self) -> RunningMode {
-        self.state.lock().running_mode
+    pub fn get_running_mode(&self) -> Arc<RunningMode> {
+        Arc::clone(&self.state.lock().running_mode)
     }
 
     pub fn set_running_mode(&self, mode: RunningMode) {
-        self.state.lock().running_mode = mode;
+        self.state.lock().running_mode = Arc::new(mode);
+    }
+
+    pub fn set_running_child_sidecar(&self, child: CommandChildGuard) {
+        self.state.lock().child_sidecar = Some(child);
     }
 
     pub async fn init(&self) -> Result<()> {
diff --git a/src-tauri/src/core/manager/state.rs b/src-tauri/src/core/manager/state.rs
index ff01a8c1..37a14a93 100644
--- a/src-tauri/src/core/manager/state.rs
+++ b/src-tauri/src/core/manager/state.rs
@@ -15,12 +15,13 @@ use anyhow::Result;
 use compact_str::CompactString;
 use flexi_logger::DeferredNow;
 use log::Level;
+use scopeguard::defer;
 use std::collections::VecDeque;
 use tauri_plugin_shell::ShellExt;
 
 impl CoreManager {
     pub async fn get_clash_logs(&self) -> Result<VecDeque<CompactString>> {
-        match self.get_running_mode() {
+        match *self.get_running_mode() {
             RunningMode::Service => service::get_clash_logs_by_service().await,
             RunningMode::Sidecar => Ok(ClashLogger::global().get_logs().clone()),
             RunningMode::NotRunning => Ok(VecDeque::new()),
@@ -49,11 +50,8 @@ impl CoreManager {
         let pid = child.pid();
         logging!(trace, Type::Core, "Sidecar started with PID: {}", pid);
 
-        {
-            let mut state = self.state.lock();
-            state.child_sidecar = Some(CommandChildGuard::new(child));
-            state.running_mode = RunningMode::Sidecar;
-        }
+        self.set_running_child_sidecar(CommandChildGuard::new(child));
+        self.set_running_mode(RunningMode::Sidecar);
 
         let shared_writer: SharedWriter =
             std::sync::Arc::new(tokio::sync::Mutex::new(sidecar_writer().await?));
@@ -93,14 +91,15 @@ impl CoreManager {
 
     pub(super) fn stop_core_by_sidecar(&self) -> Result<()> {
         logging!(info, Type::Core, "Stopping sidecar");
-
+        defer! {
+            self.set_running_mode(RunningMode::NotRunning);
+        }
         let mut state = self.state.lock();
         if let Some(child) = state.child_sidecar.take() {
             let pid = child.pid();
             drop(child);
             logging!(trace, Type::Core, "Sidecar stopped (PID: {:?})", pid);
         }
-        state.running_mode = RunningMode::NotRunning;
         Ok(())
     }
 
@@ -114,8 +113,10 @@ impl CoreManager {
 
     pub(super) async fn stop_core_by_service(&self) -> Result<()> {
         logging!(info, Type::Core, "Stopping service");
+        defer! {
+            self.set_running_mode(RunningMode::NotRunning);
+        }
         service::stop_core_by_service().await?;
-        self.set_running_mode(RunningMode::NotRunning);
         Ok(())
     }
 }
diff --git a/src-tauri/src/utils/logging.rs b/src-tauri/src/utils/logging.rs
index f4c6d740..e623b099 100644
--- a/src-tauri/src/utils/logging.rs
+++ b/src-tauri/src/utils/logging.rs
@@ -11,7 +11,7 @@ use tokio::sync::{Mutex, MutexGuard};
 
 pub type SharedWriter = Arc<Mutex<FileLogWriter>>;
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, PartialEq, Eq)]
 pub enum Type {
     Cmd,
     Core,