feat: windows service mode

src-tauri/src/cmds.rs

@@ -239,3 +239,54 @@ pub fn open_logs_dir() -> Result<(), String> {
   let log_dir = dirs::app_logs_dir();
   wrap_err!(open::that(log_dir))
 }
+
+/// service mode
+#[cfg(windows)]
+pub mod service {
+  use super::*;
+  use crate::core::win_service::JsonResponse;
+
+  #[tauri::command]
+  pub async fn start_service() -> Result<(), String> {
+    wrap_err!(crate::core::Service::start_service().await)
+  }
+
+  #[tauri::command]
+  pub async fn check_service() -> Result<JsonResponse, String> {
+    wrap_err!(crate::core::Service::check_service().await)
+  }
+
+  #[tauri::command]
+  pub async fn install_service() -> Result<(), String> {
+    wrap_err!(crate::core::Service::install_service().await)
+  }
+
+  #[tauri::command]
+  pub async fn uninstall_service() -> Result<(), String> {
+    wrap_err!(crate::core::Service::uninstall_service().await)
+  }
+}
+
+#[cfg(not(windows))]
+pub mod service {
+  use super::*;
+
+  #[tauri::command]
+  pub async fn start_service() -> Result<(), String> {
+    Ok(())
+  }
+
+  #[tauri::command]
+  pub async fn check_service() -> Result<(), String> {
+    Ok(())
+  }
+
+  #[tauri::command]
+  pub async fn install_service() -> Result<(), String> {
+    Ok(())
+  }
+  #[tauri::command]
+  pub async fn uninstall_service() -> Result<(), String> {
+    Ok(())
+  }
+}

src-tauri/src/core/mod.rs

 use self::notice::Notice;
-use self::service::Service;
 use self::sysopt::Sysopt;
 use self::timer::Timer;
 use crate::core::enhance::PrfEnhancedResult;
@@ -26,6 +25,7 @@ mod verge;
 pub use self::clash::*;
 pub use self::prfitem::*;
 pub use self::profiles::*;
+pub use self::service::*;
 pub use self::verge::*;
 
 #[derive(Clone)]
@@ -65,9 +65,22 @@ impl Core {
 
   /// initialize the core state
   pub fn init(&self, app_handle: tauri::AppHandle) {
-    let mut service = self.service.lock();
-    log_if_err!(service.start());
-    drop(service);
+    #[cfg(windows)]
+    {
+      let verge = self.verge.lock();
+      let enable = verge.enable_service_mode.clone();
+
+      let mut service = self.service.lock();
+      service.set_mode(enable.unwrap_or(false));
+
+      log_if_err!(service.start());
+    }
+
+    #[cfg(not(windows))]
+    {
+      let mut service = self.service.lock();
+      log_if_err!(service.start());
+    }
 
     log_if_err!(self.activate());
 
@@ -159,6 +172,23 @@ impl Core {
     let proxy_bypass = patch.system_proxy_bypass.clone();
     let proxy_guard = patch.enable_proxy_guard.clone();
 
+    #[cfg(windows)]
+    {
+      let service_mode = patch.enable_service_mode.clone();
+
+      if service_mode.is_some() {
+        let service_mode = service_mode.unwrap();
+
+        let mut service = self.service.lock();
+        service.stop()?;
+        service.set_mode(service_mode);
+        service.start()?;
+        drop(service);
+
+        self.activate_enhanced(false)?;
+      }
+    }
+
     if auto_launch.is_some() {
       let mut sysopt = self.sysopt.lock();
       sysopt.update_launch(auto_launch)?;

src-tauri/src/core/service.rs

@@ -3,6 +3,7 @@ use crate::log_if_err;
 use crate::utils::{config, dirs};
 use anyhow::{bail, Result};
 use reqwest::header::HeaderMap;
+use serde::{Deserialize, Serialize};
 use serde_yaml::Mapping;
 use std::{collections::HashMap, time::Duration};
 use tauri::api::process::{Command, CommandChild, CommandEvent};
@@ -11,14 +12,79 @@ use tokio::time::sleep;
 #[derive(Debug)]
 pub struct Service {
   sidecar: Option<CommandChild>,
+
+  #[allow(unused)]
+  service_mode: bool,
 }
 
 impl Service {
   pub fn new() -> Service {
-    Service { sidecar: None }
+    Service {
+      sidecar: None,
+      service_mode: false,
+    }
+  }
+
+  #[allow(unused)]
+  pub fn set_mode(&mut self, enable: bool) {
+    self.service_mode = enable;
   }
 
+  #[cfg(not(windows))]
   pub fn start(&mut self) -> Result<()> {
+    self.start_clash_by_sidecar()
+  }
+
+  #[cfg(windows)]
+  pub fn start(&mut self) -> Result<()> {
+    if !self.service_mode {
+      return self.start_clash_by_sidecar();
+    }
+
+    tauri::async_runtime::spawn(async move {
+      match Self::check_service().await {
+        Ok(status) => {
+          // 未启动clash
+          if status.code != 0 {
+            if let Err(err) = Self::start_clash_by_service().await {
+              log::error!("{err}");
+            }
+          }
+        }
+        Err(err) => log::error!("{err}"),
+      }
+    });
+
+    Ok(())
+  }
+
+  #[cfg(not(windows))]
+  pub fn stop(&mut self) -> Result<()> {
+    self.stop_clash_by_sidecar()
+  }
+
+  #[cfg(windows)]
+  pub fn stop(&mut self) -> Result<()> {
+    if !self.service_mode {
+      return self.stop_clash_by_sidecar();
+    }
+
+    tauri::async_runtime::spawn(async move {
+      if let Err(err) = Self::stop_clash_by_service().await {
+        log::error!("{err}");
+      }
+    });
+
+    Ok(())
+  }
+
+  pub fn restart(&mut self) -> Result<()> {
+    self.stop()?;
+    self.start()
+  }
+
+  /// start the clash sidecar
+  fn start_clash_by_sidecar(&mut self) -> Result<()> {
     if self.sidecar.is_some() {
       bail!("could not run clash sidecar twice");
     }
@@ -45,22 +111,18 @@ impl Service {
     Ok(())
   }
 
-  pub fn stop(&mut self) -> Result<()> {
+  /// stop the clash sidecar
+  fn stop_clash_by_sidecar(&mut self) -> Result<()> {
     if let Some(sidecar) = self.sidecar.take() {
       sidecar.kill()?;
     }
     Ok(())
   }
 
-  pub fn restart(&mut self) -> Result<()> {
-    self.stop()?;
-    self.start()
-  }
-
   /// update clash config
   /// using PUT methods
   pub fn set_config(&self, info: ClashInfo, config: Mapping, notice: Notice) -> Result<()> {
-    if self.sidecar.is_none() {
+    if !self.service_mode && self.sidecar.is_none() {
       bail!("did not start sidecar");
     }
 
@@ -125,85 +187,182 @@ impl Drop for Service {
 /// ### Service Mode
 ///
 #[cfg(windows)]
-mod win_service {
+pub mod win_service {
   use super::*;
+  use anyhow::Context;
   use deelevate::{PrivilegeLevel, Token};
   use runas::Command as RunasCommond;
-  use std::process::Command as StdCommond;
+  use std::{env::current_exe, process::Command as StdCommond};
 
   const SERVICE_NAME: &str = "clash_verge_service";
 
+  const SERVICE_URL: &str = "http://127.0.0.1:33211";
+
+  #[derive(Debug, Deserialize, Serialize, Clone)]
+  pub struct ResponseBody {
+    pub bin_path: String,
+    pub config_dir: String,
+    pub log_file: String,
+  }
+
+  #[derive(Debug, Deserialize, Serialize, Clone)]
+  pub struct JsonResponse {
+    pub code: u64,
+    pub msg: String,
+    pub data: Option<ResponseBody>,
+  }
+
   impl Service {
-    /// install the Clash Verge Service (windows only)
-    pub fn install_service(&mut self) -> Result<()> {
+    /// Install the Clash Verge Service
+    /// 该函数应该在协程或者线程中执行，避免UAC弹窗阻塞主线程
+    pub async fn install_service() -> Result<()> {
       let binary_path = dirs::service_path();
       let arg = format!("binpath={}", binary_path.as_os_str().to_string_lossy());
 
       let token = Token::with_current_process()?;
       let level = token.privilege_level()?;
 
-      tauri::async_runtime::spawn(async move {
-        let args = [
-          "create",
-          SERVICE_NAME,
-          arg.as_str(),
-          "type=own",
-          "start=AUTO",
-          "displayname=Clash Verge Service",
-        ];
-
-        let status = match level {
-          PrivilegeLevel::NotPrivileged => RunasCommond::new("sc").args(&args).status(),
-          _ => StdCommond::new("sc").args(&args).status(),
-        };
-
-        match status {
-          Ok(status) => {
-            if status.success() {
-              log::info!("install clash verge service successfully");
-            } else if status.code() == Some(1073i32) {
-              log::info!("clash verge service is installed");
-            } else {
-              log::error!(
-                "failed to install service with status {}",
-                status.code().unwrap()
-              );
-            }
-          }
-          Err(err) => log::error!("failed to install service for {err}"),
-        }
-      });
+      let args = [
+        "create",
+        SERVICE_NAME,
+        arg.as_str(),
+        "type=own",
+        "start=AUTO",
+        "displayname=Clash Verge Service",
+      ];
+
+      let status = match level {
+        PrivilegeLevel::NotPrivileged => RunasCommond::new("sc").args(&args).status()?,
+        _ => StdCommond::new("sc").args(&args).status()?,
+      };
+
+      if status.success() {
+        return Ok(());
+      }
 
-      Ok(())
+      if status.code() == Some(1073i32) {
+        bail!("clash verge service is installed");
+      }
+
+      bail!(
+        "failed to install service with status {}",
+        status.code().unwrap()
+      )
     }
 
-    /// uninstall
-    pub fn uninstall_service(&mut self) -> Result<()> {
+    /// Uninstall the Clash Verge Service
+    /// 该函数应该在协程或者线程中执行，避免UAC弹窗阻塞主线程
+    pub async fn uninstall_service() -> Result<()> {
       let token = Token::with_current_process()?;
       let level = token.privilege_level()?;
 
-      tauri::async_runtime::spawn(async move {
-        let args = ["delete", SERVICE_NAME];
-
-        let status = match level {
-          PrivilegeLevel::NotPrivileged => RunasCommond::new("sc").args(&args).status(),
-          _ => StdCommond::new("sc").args(&args).status(),
-        };
-
-        match status {
-          Ok(status) => {
-            if status.success() {
-              log::info!("uninstall clash verge service successfully");
-            } else {
-              log::error!(
-                "failed to uninstall service with status {}",
-                status.code().unwrap()
-              );
-            }
-          }
-          Err(err) => log::error!("failed to uninstall service for {err}"),
-        }
-      });
+      let args = ["delete", SERVICE_NAME];
+
+      let status = match level {
+        PrivilegeLevel::NotPrivileged => RunasCommond::new("sc").args(&args).status()?,
+        _ => StdCommond::new("sc").args(&args).status()?,
+      };
+
+      match status.success() {
+        true => Ok(()),
+        false => bail!(
+          "failed to uninstall service with status {}",
+          status.code().unwrap()
+        ),
+      }
+    }
+
+    /// start service
+    /// 该函数应该在协程或者线程中执行，避免UAC弹窗阻塞主线程
+    pub async fn start_service() -> Result<()> {
+      let token = Token::with_current_process()?;
+      let level = token.privilege_level()?;
+
+      let args = ["start", SERVICE_NAME];
+
+      let status = match level {
+        PrivilegeLevel::NotPrivileged => RunasCommond::new("sc").args(&args).status()?,
+        _ => StdCommond::new("sc").args(&args).status()?,
+      };
+
+      match status.success() {
+        true => Ok(()),
+        false => bail!(
+          "failed to start service with status {}",
+          status.code().unwrap()
+        ),
+      }
+    }
+
+    /// check the windows service status
+    pub async fn check_service() -> Result<JsonResponse> {
+      let url = format!("{SERVICE_URL}/get_clash");
+      let response = reqwest::get(url)
+        .await
+        .context("failed to connect to the Clash Verge Service")?
+        .json::<JsonResponse>()
+        .await
+        .context("failed to parse the Clash Verge Service response")?;
+
+      Ok(response)
+    }
+
+    /// start the clash by service
+    pub(super) async fn start_clash_by_service() -> Result<()> {
+      let status = Self::check_service().await?;
+
+      if status.code == 0 {
+        Self::stop_clash_by_service().await?;
+        sleep(Duration::from_secs(1)).await;
+      }
+
+      let bin_path = current_exe().unwrap().with_file_name("clash.exe");
+      let bin_path = bin_path.as_os_str().to_str().unwrap();
+
+      let config_dir = dirs::app_home_dir();
+      let config_dir = config_dir.as_os_str().to_str().unwrap();
+
+      let log_path = dirs::service_log_file();
+      let log_path = log_path.as_os_str().to_str().unwrap();
+
+      let mut map = HashMap::new();
+      map.insert("bin_path", bin_path);
+      map.insert("config_dir", config_dir);
+      map.insert("log_file", log_path);
+
+      let url = format!("{SERVICE_URL}/start_clash");
+      let res = reqwest::Client::new()
+        .post(url)
+        .json(&map)
+        .send()
+        .await
+        .context("failed to connect to the Clash Verge Service")?
+        .json::<JsonResponse>()
+        .await
+        .context("failed to parse the Clash Verge Service response")?;
+
+      if res.code != 0 {
+        bail!(res.msg);
+      }
+
+      Ok(())
+    }
+
+    /// stop the clash by service
+    pub(super) async fn stop_clash_by_service() -> Result<()> {
+      let url = format!("{SERVICE_URL}/stop_clash");
+      let res = reqwest::Client::new()
+        .post(url)
+        .send()
+        .await
+        .context("failed to connect to the Clash Verge Service")?
+        .json::<JsonResponse>()
+        .await
+        .context("failed to parse the Clash Verge Service response")?;
+
+      if res.code != 0 {
+        bail!(res.msg);
+      }
 
       Ok(())
     }

src-tauri/src/core/verge.rs

@@ -21,6 +21,10 @@ pub struct Verge {
   /// clash tun mode
   pub enable_tun_mode: Option<bool>,
 
+  /// windows service mode
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub enable_service_mode: Option<bool>,
+
   /// can the app auto startup
   pub enable_auto_launch: Option<bool>,
 
@@ -119,6 +123,9 @@ impl Verge {
     if patch.enable_tun_mode.is_some() {
       self.enable_tun_mode = patch.enable_tun_mode;
     }
+    if patch.enable_service_mode.is_some() {
+      self.enable_service_mode = patch.enable_service_mode;
+    }
 
     self.save_file()
   }

src-tauri/src/main.rs

@@ -126,7 +126,12 @@ fn main() -> std::io::Result<()> {
       cmds::change_profile_chain,
       cmds::change_profile_valid,
       cmds::read_profile_file,
-      cmds::save_profile_file
+      cmds::save_profile_file,
+      // service mode
+      cmds::service::start_service,
+      cmds::service::check_service,
+      cmds::service::install_service,
+      cmds::service::uninstall_service,
     ]);
 
   #[cfg(target_os = "macos")]

src-tauri/src/utils/dirs.rs

@@ -113,3 +113,18 @@ pub fn service_path() -> PathBuf {
     res_dir.join(SERVICE_PATH)
   }
 }
+
+#[cfg(windows)]
+pub fn service_log_file() -> PathBuf {
+  use chrono::Local;
+
+  let log_dir = app_logs_dir().join("service");
+
+  let local_time = Local::now().format("%Y-%m-%d-%H%M%S").to_string();
+  let log_file = format!("{}.log", local_time);
+  let log_file = log_dir.join(log_file);
+
+  std::fs::create_dir_all(&log_dir).unwrap();
+
+  log_file
+}