feat(system tray): support switch rule/global/direct/script mode in system tray

src-tauri/src/cmds.rs

 use crate::{
-  core::{ClashInfo, Core, PrfItem, PrfOption, Profiles, Verge},
-  utils::{dirs, help, sysopt::SysProxyConfig},
+    core::{ClashInfo, Core, PrfItem, PrfOption, Profiles, Verge},
+    utils::{dirs, help, sysopt::SysProxyConfig},
 };
 use crate::{log_if_err, ret_err, wrap_err};
 use anyhow::Result;
@@ -12,28 +12,28 @@ type CmdResult<T = ()> = Result<T, String>;
 /// get all profiles from `profiles.yaml`
 #[tauri::command]
 pub fn get_profiles(core: State<'_, Core>) -> CmdResult<Profiles> {
-  let profiles = core.profiles.lock();
-  Ok(profiles.clone())
+    let profiles = core.profiles.lock();
+    Ok(profiles.clone())
 }
 
 /// manually exec enhanced profile
 #[tauri::command]
 pub fn enhance_profiles(core: State<'_, Core>) -> CmdResult {
-  wrap_err!(core.activate_enhanced(false))
+    wrap_err!(core.activate_enhanced(false))
 }
 
 /// import the profile from url
 /// and save to `profiles.yaml`
 #[tauri::command]
 pub async fn import_profile(
-  url: String,
-  option: Option<PrfOption>,
-  core: State<'_, Core>,
+    url: String,
+    option: Option<PrfOption>,
+    core: State<'_, Core>,
 ) -> CmdResult {
-  let item = wrap_err!(PrfItem::from_url(&url, None, None, option).await)?;
+    let item = wrap_err!(PrfItem::from_url(&url, None, None, option).await)?;
 
-  let mut profiles = core.profiles.lock();
-  wrap_err!(profiles.append_item(item))
+    let mut profiles = core.profiles.lock();
+    wrap_err!(profiles.append_item(item))
 }
 
 /// new a profile
@@ -41,272 +41,276 @@ pub async fn import_profile(
 /// view the temp profile file by using vscode or other editor
 #[tauri::command]
 pub async fn create_profile(
-  item: PrfItem, // partial
-  file_data: Option<String>,
-  core: State<'_, Core>,
+    item: PrfItem, // partial
+    file_data: Option<String>,
+    core: State<'_, Core>,
 ) -> CmdResult {
-  let item = wrap_err!(PrfItem::from(item, file_data).await)?;
+    let item = wrap_err!(PrfItem::from(item, file_data).await)?;
 
-  let mut profiles = core.profiles.lock();
-  wrap_err!(profiles.append_item(item))
+    let mut profiles = core.profiles.lock();
+    wrap_err!(profiles.append_item(item))
 }
 
 /// Update the profile
 #[tauri::command]
 pub async fn update_profile(
-  index: String,
-  option: Option<PrfOption>,
-  core: State<'_, Core>,
+    index: String,
+    option: Option<PrfOption>,
+    core: State<'_, Core>,
 ) -> CmdResult {
-  wrap_err!(Core::update_profile_item(core.inner().clone(), index, option).await)
+    wrap_err!(Core::update_profile_item(core.inner().clone(), index, option).await)
 }
 
 /// change the current profile
 #[tauri::command]
 pub fn select_profile(index: String, core: State<'_, Core>) -> CmdResult {
-  let mut profiles = core.profiles.lock();
-  wrap_err!(profiles.put_current(index))?;
+    let mut profiles = core.profiles.lock();
+    wrap_err!(profiles.put_current(index))?;
 
-  drop(profiles);
+    drop(profiles);
 
-  wrap_err!(core.activate_enhanced(false))
+    wrap_err!(core.activate_enhanced(false))
 }
 
 /// change the profile chain
 #[tauri::command]
 pub fn change_profile_chain(chain: Option<Vec<String>>, core: State<'_, Core>) -> CmdResult {
-  let mut profiles = core.profiles.lock();
-  profiles.put_chain(chain);
+    let mut profiles = core.profiles.lock();
+    profiles.put_chain(chain);
 
-  drop(profiles);
+    drop(profiles);
 
-  wrap_err!(core.activate_enhanced(false))
+    wrap_err!(core.activate_enhanced(false))
 }
 
 /// change the profile valid fields
 #[tauri::command]
 pub fn change_profile_valid(valid: Option<Vec<String>>, core: State<Core>) -> CmdResult {
-  let mut profiles = core.profiles.lock();
-  profiles.put_valid(valid);
+    let mut profiles = core.profiles.lock();
+    profiles.put_valid(valid);
 
-  drop(profiles);
+    drop(profiles);
 
-  wrap_err!(core.activate_enhanced(false))
+    wrap_err!(core.activate_enhanced(false))
 }
 
 /// delete profile item
 #[tauri::command]
 pub fn delete_profile(index: String, core: State<'_, Core>) -> CmdResult {
-  let mut profiles = core.profiles.lock();
+    let mut profiles = core.profiles.lock();
 
-  if wrap_err!(profiles.delete_item(index))? {
-    drop(profiles);
+    if wrap_err!(profiles.delete_item(index))? {
+        drop(profiles);
 
-    log_if_err!(core.activate_enhanced(false));
-  }
+        log_if_err!(core.activate_enhanced(false));
+    }
 
-  Ok(())
+    Ok(())
 }
 
 /// patch the profile config
 #[tauri::command]
 pub fn patch_profile(index: String, profile: PrfItem, core: State<'_, Core>) -> CmdResult {
-  let mut profiles = core.profiles.lock();
-  wrap_err!(profiles.patch_item(index, profile))?;
-  drop(profiles);
+    let mut profiles = core.profiles.lock();
+    wrap_err!(profiles.patch_item(index, profile))?;
+    drop(profiles);
 
-  // update cron task
-  let mut timer = core.timer.lock();
-  wrap_err!(timer.refresh())
+    // update cron task
+    let mut timer = core.timer.lock();
+    wrap_err!(timer.refresh())
 }
 
 /// run vscode command to edit the profile
 #[tauri::command]
 pub fn view_profile(index: String, core: State<'_, Core>) -> CmdResult {
-  let profiles = core.profiles.lock();
-  let item = wrap_err!(profiles.get_item(&index))?;
+    let profiles = core.profiles.lock();
+    let item = wrap_err!(profiles.get_item(&index))?;
 
-  let file = item.file.clone();
-  if file.is_none() {
-    ret_err!("the file is null");
-  }
+    let file = item.file.clone();
+    if file.is_none() {
+        ret_err!("the file is null");
+    }
 
-  let path = dirs::app_profiles_dir().join(file.unwrap());
-  if !path.exists() {
-    ret_err!("the file not found");
-  }
+    let path = dirs::app_profiles_dir().join(file.unwrap());
+    if !path.exists() {
+        ret_err!("the file not found");
+    }
 
-  wrap_err!(help::open_file(path))
+    wrap_err!(help::open_file(path))
 }
 
 /// read the profile item file data
 #[tauri::command]
 pub fn read_profile_file(index: String, core: State<'_, Core>) -> CmdResult<String> {
-  let profiles = core.profiles.lock();
+    let profiles = core.profiles.lock();
 
-  let item = wrap_err!(profiles.get_item(&index))?;
-  let data = wrap_err!(item.read_file())?;
+    let item = wrap_err!(profiles.get_item(&index))?;
+    let data = wrap_err!(item.read_file())?;
 
-  Ok(data)
+    Ok(data)
 }
 
 /// save the profile item file data
 #[tauri::command]
 pub fn save_profile_file(
-  index: String,
-  file_data: Option<String>,
-  core: State<'_, Core>,
+    index: String,
+    file_data: Option<String>,
+    core: State<'_, Core>,
 ) -> CmdResult {
-  if file_data.is_none() {
-    return Ok(());
-  }
+    if file_data.is_none() {
+        return Ok(());
+    }
 
-  let profiles = core.profiles.lock();
-  let item = wrap_err!(profiles.get_item(&index))?;
-  wrap_err!(item.save_file(file_data.unwrap()))
+    let profiles = core.profiles.lock();
+    let item = wrap_err!(profiles.get_item(&index))?;
+    wrap_err!(item.save_file(file_data.unwrap()))
 }
 
 /// get the clash core info from the state
 /// the caller can also get the infomation by clash's api
 #[tauri::command]
 pub fn get_clash_info(core: State<'_, Core>) -> CmdResult<ClashInfo> {
-  let clash = core.clash.lock();
-  Ok(clash.info.clone())
+    let clash = core.clash.lock();
+    Ok(clash.info.clone())
 }
 
 /// update the clash core config
 /// after putting the change to the clash core
 /// then we should save the latest config
 #[tauri::command]
-pub fn patch_clash_config(payload: Mapping, core: State<'_, Core>) -> CmdResult {
-  wrap_err!(core.patch_clash(payload))
+pub fn patch_clash_config(
+    payload: Mapping,
+    app_handle: tauri::AppHandle,
+    core: State<'_, Core>,
+) -> CmdResult {
+    wrap_err!(core.patch_clash(payload, &app_handle))
 }
 
 /// get the verge config
 #[tauri::command]
 pub fn get_verge_config(core: State<'_, Core>) -> CmdResult<Verge> {
-  let verge = core.verge.lock();
-  Ok(verge.clone())
+    let verge = core.verge.lock();
+    Ok(verge.clone())
 }
 
 /// patch the verge config
 /// this command only save the config and not responsible for other things
 #[tauri::command]
 pub fn patch_verge_config(
-  payload: Verge,
-  app_handle: tauri::AppHandle,
-  core: State<'_, Core>,
+    payload: Verge,
+    app_handle: tauri::AppHandle,
+    core: State<'_, Core>,
 ) -> CmdResult {
-  wrap_err!(core.patch_verge(payload, &app_handle))
+    wrap_err!(core.patch_verge(payload, &app_handle))
 }
 
 /// change clash core
 #[tauri::command]
 pub fn change_clash_core(core: State<'_, Core>, clash_core: Option<String>) -> CmdResult {
-  wrap_err!(core.change_core(clash_core))
+    wrap_err!(core.change_core(clash_core))
 }
 
 /// restart the sidecar
 #[tauri::command]
 pub fn restart_sidecar(core: State<'_, Core>) -> CmdResult {
-  wrap_err!(core.restart_clash())
+    wrap_err!(core.restart_clash())
 }
 
 /// kill all sidecars when update app
 #[tauri::command]
 pub fn kill_sidecar() {
-  api::process::kill_children();
+    api::process::kill_children();
 }
 
 /// get the system proxy
 #[tauri::command]
 pub fn get_sys_proxy() -> Result<SysProxyConfig, String> {
-  wrap_err!(SysProxyConfig::get_sys())
+    wrap_err!(SysProxyConfig::get_sys())
 }
 
 /// get the current proxy config
 /// which may not the same as system proxy
 #[tauri::command]
 pub fn get_cur_proxy(core: State<'_, Core>) -> CmdResult<Option<SysProxyConfig>> {
-  let sysopt = core.sysopt.lock();
-  wrap_err!(sysopt.get_sysproxy())
+    let sysopt = core.sysopt.lock();
+    wrap_err!(sysopt.get_sysproxy())
 }
 
 /// open app config dir
 #[tauri::command]
 pub fn open_app_dir() -> Result<(), String> {
-  let app_dir = dirs::app_home_dir();
-  wrap_err!(open::that(app_dir))
+    let app_dir = dirs::app_home_dir();
+    wrap_err!(open::that(app_dir))
 }
 
 /// open logs dir
 #[tauri::command]
 pub fn open_logs_dir() -> Result<(), String> {
-  let log_dir = dirs::app_logs_dir();
-  wrap_err!(open::that(log_dir))
+    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 stop_service() -> Result<(), String> {
-    wrap_err!(crate::core::Service::stop_service().await)
-  }
-
-  #[tauri::command]
-  pub async fn check_service() -> Result<JsonResponse, String> {
-    // no log
-    match crate::core::Service::check_service().await {
-      Ok(res) => Ok(res),
-      Err(err) => Err(err.to_string()),
+    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 stop_service() -> Result<(), String> {
+        wrap_err!(crate::core::Service::stop_service().await)
     }
-  }
 
-  #[tauri::command]
-  pub async fn install_service() -> Result<(), String> {
-    wrap_err!(crate::core::Service::install_service().await)
-  }
+    #[tauri::command]
+    pub async fn check_service() -> Result<JsonResponse, String> {
+        // no log
+        match crate::core::Service::check_service().await {
+            Ok(res) => Ok(res),
+            Err(err) => Err(err.to_string()),
+        }
+    }
+
+    #[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)
-  }
+    #[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::*;
+    use super::*;
 
-  #[tauri::command]
-  pub async fn start_service() -> Result<(), String> {
-    Ok(())
-  }
+    #[tauri::command]
+    pub async fn start_service() -> Result<(), String> {
+        Ok(())
+    }
 
-  #[tauri::command]
-  pub async fn stop_service() -> Result<(), String> {
-    Ok(())
-  }
+    #[tauri::command]
+    pub async fn stop_service() -> Result<(), String> {
+        Ok(())
+    }
 
-  #[tauri::command]
-  pub async fn check_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(())
-  }
+    #[tauri::command]
+    pub async fn install_service() -> Result<(), String> {
+        Ok(())
+    }
+    #[tauri::command]
+    pub async fn uninstall_service() -> Result<(), String> {
+        Ok(())
+    }
 }

src-tauri/src/core/clash.rs

@@ -5,285 +5,304 @@ use serde_yaml::{Mapping, Value};
 
 #[derive(Default, Debug, Clone, Deserialize, Serialize)]
 pub struct ClashInfo {
-  /// clash sidecar status
-  pub status: String,
+    /// clash sidecar status
+    pub status: String,
 
-  /// clash core port
-  pub port: Option<String>,
+    /// clash core port
+    pub port: Option<String>,
 
-  /// same as `external-controller`
-  pub server: Option<String>,
+    /// same as `external-controller`
+    pub server: Option<String>,
 
-  /// clash secret
-  pub secret: Option<String>,
+    /// clash secret
+    pub secret: Option<String>,
+
+    /// mode
+    pub mode: Option<String>,
 }
 
 impl ClashInfo {
-  /// parse the clash's config.yaml
-  /// get some information
-  pub fn from(config: &Mapping) -> ClashInfo {
-    let key_port_1 = Value::from("port");
-    let key_port_2 = Value::from("mixed-port");
-    let key_server = Value::from("external-controller");
-    let key_secret = Value::from("secret");
-
-    let port = match config.get(&key_port_1) {
-      Some(value) => match value {
-        Value::String(val_str) => Some(val_str.clone()),
-        Value::Number(val_num) => Some(val_num.to_string()),
-        _ => None,
-      },
-      _ => None,
-    };
-    let port = match port {
-      Some(_) => port,
-      None => match config.get(&key_port_2) {
-        Some(value) => match value {
-          Value::String(val_str) => Some(val_str.clone()),
-          Value::Number(val_num) => Some(val_num.to_string()),
-          _ => None,
-        },
-        _ => None,
-      },
-    };
-
-    // `external-controller` could be
-    // "127.0.0.1:9090" or ":9090"
-    let server = match config.get(&key_server) {
-      Some(value) => {
-        let val_str = value.as_str().unwrap_or("");
-
-        if val_str.starts_with(":") {
-          Some(format!("127.0.0.1{val_str}"))
-        } else {
-          Some(val_str.into())
+    /// parse the clash's config.yaml
+    /// get some information
+    pub fn from(config: &Mapping) -> ClashInfo {
+        let key_port_1 = Value::from("port");
+        let key_port_2 = Value::from("mixed-port");
+        let key_server = Value::from("external-controller");
+        let key_secret = Value::from("secret");
+        let key_mode = Value::from("mode");
+
+        let port = match config.get(&key_port_1) {
+            Some(value) => match value {
+                Value::String(val_str) => Some(val_str.clone()),
+                Value::Number(val_num) => Some(val_num.to_string()),
+                _ => None,
+            },
+            _ => None,
+        };
+        let port = match port {
+            Some(_) => port,
+            None => match config.get(&key_port_2) {
+                Some(value) => match value {
+                    Value::String(val_str) => Some(val_str.clone()),
+                    Value::Number(val_num) => Some(val_num.to_string()),
+                    _ => None,
+                },
+                _ => None,
+            },
+        };
+
+        // `external-controller` could be
+        // "127.0.0.1:9090" or ":9090"
+        let server = match config.get(&key_server) {
+            Some(value) => {
+                let val_str = value.as_str().unwrap_or("");
+
+                if val_str.starts_with(":") {
+                    Some(format!("127.0.0.1{val_str}"))
+                } else {
+                    Some(val_str.into())
+                }
+            }
+            _ => None,
+        };
+
+        let secret = match config.get(&key_secret) {
+            Some(value) => match value {
+                Value::String(val_str) => Some(val_str.clone()),
+                Value::Bool(val_bool) => Some(val_bool.to_string()),
+                Value::Number(val_num) => Some(val_num.to_string()),
+                _ => None,
+            },
+            _ => None,
+        };
+
+        let mode = match config.get(&key_mode) {
+            Some(value) => match value {
+                Value::String(val_str) => Some(val_str.clone()),
+                _ => None,
+            },
+            _ => None,
+        };
+
+        ClashInfo {
+            status: "init".into(),
+            port,
+            server,
+            secret,
+            mode,
         }
-      }
-      _ => None,
-    };
-
-    let secret = match config.get(&key_secret) {
-      Some(value) => match value {
-        Value::String(val_str) => Some(val_str.clone()),
-        Value::Bool(val_bool) => Some(val_bool.to_string()),
-        Value::Number(val_num) => Some(val_num.to_string()),
-        _ => None,
-      },
-      _ => None,
-    };
-
-    ClashInfo {
-      status: "init".into(),
-      port,
-      server,
-      secret,
     }
-  }
 }
 
 pub struct Clash {
-  /// maintain the clash config
-  pub config: Mapping,
+    /// maintain the clash config
+    pub config: Mapping,
 
-  /// some info
-  pub info: ClashInfo,
+    /// some info
+    pub info: ClashInfo,
 }
 
 impl Clash {
-  pub fn new() -> Clash {
-    let config = Clash::read_config();
-    let info = ClashInfo::from(&config);
-
-    Clash { config, info }
-  }
-
-  /// get clash config
-  pub fn read_config() -> Mapping {
-    config::read_yaml::<Mapping>(dirs::clash_path())
-  }
-
-  /// save the clash config
-  pub fn save_config(&self) -> Result<()> {
-    config::save_yaml(
-      dirs::clash_path(),
-      &self.config,
-      Some("# Default Config For Clash Core\n\n"),
-    )
-  }
-
-  /// patch update the clash config
-  /// if the port is changed then return true
-  pub fn patch_config(&mut self, patch: Mapping) -> Result<bool> {
-    let port_key = Value::from("mixed-port");
-    let server_key = Value::from("external-controller");
-    let secret_key = Value::from("secret");
-
-    let mut change_port = false;
-    let mut change_info = false;
-
-    for (key, value) in patch.into_iter() {
-      if key == port_key {
-        change_port = true;
-      }
-
-      if key == port_key || key == server_key || key == secret_key {
-        change_info = true;
-      }
-
-      self.config.insert(key, value);
+    pub fn new() -> Clash {
+        let config = Clash::read_config();
+        let info = ClashInfo::from(&config);
+
+        Clash { config, info }
     }
 
-    if change_info {
-      self.info = ClashInfo::from(&self.config);
+    /// get clash config
+    pub fn read_config() -> Mapping {
+        config::read_yaml::<Mapping>(dirs::clash_path())
     }
 
-    self.save_config()?;
+    /// save the clash config
+    pub fn save_config(&self) -> Result<()> {
+        config::save_yaml(
+            dirs::clash_path(),
+            &self.config,
+            Some("# Default Config For Clash Core\n\n"),
+        )
+    }
 
-    Ok(change_port)
-  }
+    /// patch update the clash config
+    /// if the port is changed then return true
+    pub fn patch_config(&mut self, patch: Mapping) -> Result<(bool, bool)> {
+        let port_key = Value::from("mixed-port");
+        let server_key = Value::from("external-controller");
+        let secret_key = Value::from("secret");
+        let mode_key = Value::from("mode");
 
-  /// revise the `tun` and `dns` config
-  pub fn _tun_mode(mut config: Mapping, enable: bool) -> Mapping {
-    macro_rules! revise {
-      ($map: expr, $key: expr, $val: expr) => {
-        let ret_key = Value::String($key.into());
-        $map.insert(ret_key, Value::from($val));
-      };
-    }
+        let mut change_port = false;
+        let mut change_info = false;
+        let mut change_mode = false;
+
+        for (key, value) in patch.into_iter() {
+            if key == port_key {
+                change_port = true;
+            }
+
+            if key == mode_key {
+                change_mode = true;
+            }
+
+            if key == port_key || key == server_key || key == secret_key || key == mode_key {
+                change_info = true;
+            }
 
-    // if key not exists then append value
-    macro_rules! append {
-      ($map: expr, $key: expr, $val: expr) => {
-        let ret_key = Value::String($key.into());
-        if !$map.contains_key(&ret_key) {
-          $map.insert(ret_key, Value::from($val));
+            self.config.insert(key, value);
+        }
+
+        if change_info {
+            self.info = ClashInfo::from(&self.config);
         }
-      };
-    }
 
-    // tun config
-    let tun_val = config.get(&Value::from("tun"));
-    let mut new_tun = Mapping::new();
+        self.save_config()?;
 
-    if tun_val.is_some() && tun_val.as_ref().unwrap().is_mapping() {
-      new_tun = tun_val.as_ref().unwrap().as_mapping().unwrap().clone();
+        Ok((change_port, change_mode))
     }
 
-    revise!(new_tun, "enable", enable);
+    /// revise the `tun` and `dns` config
+    pub fn _tun_mode(mut config: Mapping, enable: bool) -> Mapping {
+        macro_rules! revise {
+            ($map: expr, $key: expr, $val: expr) => {
+                let ret_key = Value::String($key.into());
+                $map.insert(ret_key, Value::from($val));
+            };
+        }
 
-    if enable {
-      append!(new_tun, "stack", "gvisor");
-      append!(new_tun, "dns-hijack", vec!["198.18.0.2:53"]);
-      append!(new_tun, "auto-route", true);
-      append!(new_tun, "auto-detect-interface", true);
-    }
+        // if key not exists then append value
+        macro_rules! append {
+            ($map: expr, $key: expr, $val: expr) => {
+                let ret_key = Value::String($key.into());
+                if !$map.contains_key(&ret_key) {
+                    $map.insert(ret_key, Value::from($val));
+                }
+            };
+        }
 
-    revise!(config, "tun", new_tun);
-
-    if enable {
-      // dns config
-      let dns_val = config.get(&Value::from("dns"));
-      let mut new_dns = Mapping::new();
-
-      if dns_val.is_some() && dns_val.as_ref().unwrap().is_mapping() {
-        new_dns = dns_val.as_ref().unwrap().as_mapping().unwrap().clone();
-      }
-      revise!(new_dns, "enable", enable);
-
-      // 借鉴cfw的默认配置
-      append!(new_dns, "enhanced-mode", "fake-ip");
-      append!(
-        new_dns,
-        "nameserver",
-        vec!["114.114.114.114", "223.5.5.5", "8.8.8.8"]
-      );
-      append!(new_dns, "fallback", vec![] as Vec<&str>);
-
-      #[cfg(target_os = "windows")]
-      append!(
-        new_dns,
-        "fake-ip-filter",
-        vec![
-          "dns.msftncsi.com",
-          "www.msftncsi.com",
-          "www.msftconnecttest.com"
-        ]
-      );
-
-      revise!(config, "dns", new_dns);
-    }
+        // tun config
+        let tun_val = config.get(&Value::from("tun"));
+        let mut new_tun = Mapping::new();
+
+        if tun_val.is_some() && tun_val.as_ref().unwrap().is_mapping() {
+            new_tun = tun_val.as_ref().unwrap().as_mapping().unwrap().clone();
+        }
+
+        revise!(new_tun, "enable", enable);
+
+        if enable {
+            append!(new_tun, "stack", "gvisor");
+            append!(new_tun, "dns-hijack", vec!["198.18.0.2:53"]);
+            append!(new_tun, "auto-route", true);
+            append!(new_tun, "auto-detect-interface", true);
+        }
 
-    config
-  }
-
-  /// only 5 default fields available (clash config fields)
-  /// convert to lowercase
-  pub fn strict_filter(config: Mapping) -> Mapping {
-    // Only the following fields are allowed:
-    // proxies/proxy-providers/proxy-groups/rule-providers/rules
-    let valid_keys = vec![
-      "proxies",
-      "proxy-providers",
-      "proxy-groups",
-      "rules",
-      "rule-providers",
-    ];
-
-    let mut new_config = Mapping::new();
-
-    for (key, value) in config.into_iter() {
-      key.as_str().map(|key_str| {
-        // change to lowercase
-        let mut key_str = String::from(key_str);
-        key_str.make_ascii_lowercase();
-
-        // filter
-        if valid_keys.contains(&&*key_str) {
-          new_config.insert(Value::String(key_str), value);
+        revise!(config, "tun", new_tun);
+
+        if enable {
+            // dns config
+            let dns_val = config.get(&Value::from("dns"));
+            let mut new_dns = Mapping::new();
+
+            if dns_val.is_some() && dns_val.as_ref().unwrap().is_mapping() {
+                new_dns = dns_val.as_ref().unwrap().as_mapping().unwrap().clone();
+            }
+            revise!(new_dns, "enable", enable);
+
+            // 借鉴cfw的默认配置
+            append!(new_dns, "enhanced-mode", "fake-ip");
+            append!(
+                new_dns,
+                "nameserver",
+                vec!["114.114.114.114", "223.5.5.5", "8.8.8.8"]
+            );
+            append!(new_dns, "fallback", vec![] as Vec<&str>);
+
+            #[cfg(target_os = "windows")]
+            append!(
+                new_dns,
+                "fake-ip-filter",
+                vec![
+                    "dns.msftncsi.com",
+                    "www.msftncsi.com",
+                    "www.msftconnecttest.com"
+                ]
+            );
+
+            revise!(config, "dns", new_dns);
         }
-      });
+
+        config
     }
 
-    new_config
-  }
-
-  /// more clash config fields available
-  /// convert to lowercase
-  pub fn loose_filter(config: Mapping) -> Mapping {
-    // all of these can not be revised by script or merge
-    // http/https/socks port should be under control
-    let not_allow = vec![
-      "port",
-      "socks-port",
-      "mixed-port",
-      "allow-lan",
-      "mode",
-      "external-controller",
-      "secret",
-      "log-level",
-    ];
-
-    let mut new_config = Mapping::new();
-
-    for (key, value) in config.into_iter() {
-      key.as_str().map(|key_str| {
-        // change to lowercase
-        let mut key_str = String::from(key_str);
-        key_str.make_ascii_lowercase();
-
-        // filter
-        if !not_allow.contains(&&*key_str) {
-          new_config.insert(Value::String(key_str), value);
+    /// only 5 default fields available (clash config fields)
+    /// convert to lowercase
+    pub fn strict_filter(config: Mapping) -> Mapping {
+        // Only the following fields are allowed:
+        // proxies/proxy-providers/proxy-groups/rule-providers/rules
+        let valid_keys = vec![
+            "proxies",
+            "proxy-providers",
+            "proxy-groups",
+            "rules",
+            "rule-providers",
+        ];
+
+        let mut new_config = Mapping::new();
+
+        for (key, value) in config.into_iter() {
+            key.as_str().map(|key_str| {
+                // change to lowercase
+                let mut key_str = String::from(key_str);
+                key_str.make_ascii_lowercase();
+
+                // filter
+                if valid_keys.contains(&&*key_str) {
+                    new_config.insert(Value::String(key_str), value);
+                }
+            });
         }
-      });
+
+        new_config
     }
 
-    new_config
-  }
+    /// more clash config fields available
+    /// convert to lowercase
+    pub fn loose_filter(config: Mapping) -> Mapping {
+        // all of these can not be revised by script or merge
+        // http/https/socks port should be under control
+        let not_allow = vec![
+            "port",
+            "socks-port",
+            "mixed-port",
+            "allow-lan",
+            "mode",
+            "external-controller",
+            "secret",
+            "log-level",
+        ];
+
+        let mut new_config = Mapping::new();
+
+        for (key, value) in config.into_iter() {
+            key.as_str().map(|key_str| {
+                // change to lowercase
+                let mut key_str = String::from(key_str);
+                key_str.make_ascii_lowercase();
+
+                // filter
+                if !not_allow.contains(&&*key_str) {
+                    new_config.insert(Value::String(key_str), value);
+                }
+            });
+        }
+
+        new_config
+    }
 }
 
 impl Default for Clash {
-  fn default() -> Self {
-    Clash::new()
-  }
+    fn default() -> Self {
+        Clash::new()
+    }
 }

src-tauri/src/core/notice.rs

@@ -3,33 +3,33 @@ use tauri::Window;
 
 #[derive(Debug, Default, Clone)]
 pub struct Notice {
-  win: Option<Window>,
+    win: Option<Window>,
 }
 
 impl Notice {
-  pub fn from(win: Option<Window>) -> Notice {
-    Notice { win }
-  }
+    pub fn from(win: Option<Window>) -> Notice {
+        Notice { win }
+    }
 
-  pub fn set_win(&mut self, win: Option<Window>) {
-    self.win = win;
-  }
+    pub fn set_win(&mut self, win: Option<Window>) {
+        self.win = win;
+    }
 
-  pub fn refresh_clash(&self) {
-    if let Some(window) = self.win.as_ref() {
-      log_if_err!(window.emit("verge://refresh-clash-config", "yes"));
+    pub fn refresh_clash(&self) {
+        if let Some(window) = self.win.as_ref() {
+            log_if_err!(window.emit("verge://refresh-clash-config", "yes"));
+        }
     }
-  }
 
-  pub fn refresh_verge(&self) {
-    if let Some(window) = self.win.as_ref() {
-      log_if_err!(window.emit("verge://refresh-verge-config", "yes"));
+    pub fn refresh_verge(&self) {
+        if let Some(window) = self.win.as_ref() {
+            log_if_err!(window.emit("verge://refresh-verge-config", "yes"));
+        }
     }
-  }
 
-  pub fn refresh_profiles(&self) {
-    if let Some(window) = self.win.as_ref() {
-      log_if_err!(window.emit("verge://refresh-profiles-config", "yes"));
+    pub fn refresh_profiles(&self) {
+        if let Some(window) = self.win.as_ref() {
+            log_if_err!(window.emit("verge://refresh-profiles-config", "yes"));
+        }
     }
-  }
 }

src-tauri/src/main.rs

 #![cfg_attr(
-  all(not(debug_assertions), target_os = "windows"),
-  windows_subsystem = "windows"
+    all(not(debug_assertions), target_os = "windows"),
+    windows_subsystem = "windows"
 )]
 
 mod cmds;
@@ -8,156 +8,177 @@ mod core;
 mod utils;
 
 use crate::{
-  core::Verge,
-  utils::{resolve, server},
+    core::Verge,
+    utils::{resolve, server},
 };
+use serde_yaml::{Mapping, Value};
 use tauri::{
-  api, CustomMenuItem, Manager, SystemTray, SystemTrayEvent, SystemTrayMenu, SystemTrayMenuItem,
+    api, CustomMenuItem, Manager, SystemTray, SystemTrayEvent, SystemTrayMenu, SystemTrayMenuItem,
 };
 
 fn main() -> std::io::Result<()> {
-  if server::check_singleton().is_err() {
-    println!("app exists");
-    return Ok(());
-  }
-
-  #[cfg(target_os = "windows")]
-  unsafe {
-    use crate::utils::dirs;
-
-    dirs::init_portable_flag();
-  }
-
-  let tray_menu = SystemTrayMenu::new()
-    .add_item(CustomMenuItem::new("open_window", "Show"))
-    .add_item(CustomMenuItem::new("system_proxy", "System Proxy"))
-    .add_item(CustomMenuItem::new("tun_mode", "Tun Mode"))
-    .add_item(CustomMenuItem::new("restart_clash", "Restart Clash"))
-    .add_native_item(SystemTrayMenuItem::Separator)
-    .add_item(CustomMenuItem::new("quit", "Quit").accelerator("CmdOrControl+Q"));
-
-  #[allow(unused_mut)]
-  let mut builder = tauri::Builder::default()
-    .setup(|app| Ok(resolve::resolve_setup(app)))
-    .system_tray(SystemTray::new().with_menu(tray_menu))
-    .on_system_tray_event(move |app_handle, event| match event {
-      SystemTrayEvent::MenuItemClick { id, .. } => match id.as_str() {
-        "open_window" => {
-          resolve::create_window(app_handle);
-        }
-        "system_proxy" => {
-          let core = app_handle.state::<core::Core>();
-
-          let new_value = {
-            let verge = core.verge.lock();
-            !verge.enable_system_proxy.clone().unwrap_or(false)
-          };
-
-          let patch = Verge {
-            enable_system_proxy: Some(new_value),
-            ..Verge::default()
-          };
-
-          crate::log_if_err!(core.patch_verge(patch, app_handle));
-        }
-        "tun_mode" => {
-          let core = app_handle.state::<core::Core>();
-
-          let new_value = {
-            let verge = core.verge.lock();
-            !verge.enable_tun_mode.clone().unwrap_or(false)
-          };
-
-          let patch = Verge {
-            enable_tun_mode: Some(new_value),
-            ..Verge::default()
-          };
-
-          crate::log_if_err!(core.patch_verge(patch, app_handle));
-        }
-        "restart_clash" => {
-          let core = app_handle.state::<core::Core>();
-          crate::log_if_err!(core.restart_clash());
-        }
-        "quit" => {
-          resolve::resolve_reset(app_handle);
-          app_handle.exit(0);
-        }
-        _ => {}
-      },
-      #[cfg(target_os = "windows")]
-      SystemTrayEvent::LeftClick { .. } => {
-        resolve::create_window(app_handle);
-      }
-      _ => {}
-    })
-    .invoke_handler(tauri::generate_handler![
-      // common
-      cmds::get_sys_proxy,
-      cmds::get_cur_proxy,
-      cmds::open_app_dir,
-      cmds::open_logs_dir,
-      cmds::kill_sidecar,
-      cmds::restart_sidecar,
-      // clash
-      cmds::get_clash_info,
-      cmds::patch_clash_config,
-      cmds::change_clash_core,
-      // verge
-      cmds::get_verge_config,
-      cmds::patch_verge_config,
-      // profile
-      cmds::view_profile,
-      cmds::patch_profile,
-      cmds::create_profile,
-      cmds::import_profile,
-      cmds::update_profile,
-      cmds::delete_profile,
-      cmds::select_profile,
-      cmds::get_profiles,
-      cmds::enhance_profiles,
-      cmds::change_profile_chain,
-      cmds::change_profile_valid,
-      cmds::read_profile_file,
-      cmds::save_profile_file,
-      // service mode
-      cmds::service::start_service,
-      cmds::service::stop_service,
-      cmds::service::check_service,
-      cmds::service::install_service,
-      cmds::service::uninstall_service,
-    ]);
-
-  #[cfg(target_os = "macos")]
-  {
-    use tauri::{Menu, MenuItem, Submenu};
-
-    let submenu_file = Submenu::new(
-      "File",
-      Menu::new()
-        .add_native_item(MenuItem::Undo)
-        .add_native_item(MenuItem::Redo)
-        .add_native_item(MenuItem::Copy)
-        .add_native_item(MenuItem::Paste)
-        .add_native_item(MenuItem::Cut)
-        .add_native_item(MenuItem::SelectAll),
-    );
-    builder = builder.menu(Menu::new().add_submenu(submenu_file));
-  }
-
-  builder
-    .build(tauri::generate_context!())
-    .expect("error while running tauri application")
-    .run(|app_handle, e| match e {
-      tauri::RunEvent::ExitRequested { api, .. } => {
-        api.prevent_exit();
-      }
-      tauri::RunEvent::Exit => {
-        resolve::resolve_reset(app_handle);
-        api::process::kill_children();
-      }
-      _ => {}
-    });
-
-  Ok(())
+    if server::check_singleton().is_err() {
+        println!("app exists");
+        return Ok(());
+    }
+
+    #[cfg(target_os = "windows")]
+    unsafe {
+        use crate::utils::dirs;
+
+        dirs::init_portable_flag();
+    }
+
+    let tray_menu = SystemTrayMenu::new()
+        .add_item(CustomMenuItem::new("open_window", "Show"))
+        .add_item(CustomMenuItem::new("rule_mode", "Rule Mode"))
+        .add_item(CustomMenuItem::new("global_mode", "Global Mode"))
+        .add_item(CustomMenuItem::new("direct_mode", "Direct Mode"))
+        .add_item(CustomMenuItem::new("script_mode", "Script Mode"))
+        .add_item(CustomMenuItem::new("system_proxy", "System Proxy"))
+        .add_item(CustomMenuItem::new("tun_mode", "Tun Mode"))
+        .add_item(CustomMenuItem::new("restart_clash", "Restart Clash"))
+        .add_native_item(SystemTrayMenuItem::Separator)
+        .add_item(CustomMenuItem::new("quit", "Quit").accelerator("CmdOrControl+Q"));
+
+    #[allow(unused_mut)]
+    let mut builder = tauri::Builder::default()
+        .setup(|app| Ok(resolve::resolve_setup(app)))
+        .system_tray(SystemTray::new().with_menu(tray_menu))
+        .on_system_tray_event(move |app_handle, event| match event {
+            SystemTrayEvent::MenuItemClick { id, .. } => match id.as_str() {
+                "open_window" => {
+                    resolve::create_window(app_handle);
+                }
+                "rule_mode" => {
+                    let core = app_handle.state::<core::Core>();
+                    crate::log_if_err!(core.update_mode(app_handle, "rule"));
+                }
+                "global_mode" => {
+                    let core = app_handle.state::<core::Core>();
+                    crate::log_if_err!(core.update_mode(app_handle, "global"));
+                }
+                "direct_mode" => {
+                    let core = app_handle.state::<core::Core>();
+                    crate::log_if_err!(core.update_mode(app_handle, "direct"));
+                }
+                "script_mode" => {
+                    let core = app_handle.state::<core::Core>();
+                    crate::log_if_err!(core.update_mode(app_handle, "script"));
+                }
+                "system_proxy" => {
+                    let core = app_handle.state::<core::Core>();
+
+                    let new_value = {
+                        let verge = core.verge.lock();
+                        !verge.enable_system_proxy.clone().unwrap_or(false)
+                    };
+
+                    let patch = Verge {
+                        enable_system_proxy: Some(new_value),
+                        ..Verge::default()
+                    };
+
+                    crate::log_if_err!(core.patch_verge(patch, app_handle));
+                }
+                "tun_mode" => {
+                    let core = app_handle.state::<core::Core>();
+
+                    let new_value = {
+                        let verge = core.verge.lock();
+                        !verge.enable_tun_mode.clone().unwrap_or(false)
+                    };
+
+                    let patch = Verge {
+                        enable_tun_mode: Some(new_value),
+                        ..Verge::default()
+                    };
+
+                    crate::log_if_err!(core.patch_verge(patch, app_handle));
+                }
+                "restart_clash" => {
+                    let core = app_handle.state::<core::Core>();
+                    crate::log_if_err!(core.restart_clash());
+                }
+                "quit" => {
+                    resolve::resolve_reset(app_handle);
+                    app_handle.exit(0);
+                }
+                _ => {}
+            },
+            #[cfg(target_os = "windows")]
+            SystemTrayEvent::LeftClick { .. } => {
+                resolve::create_window(app_handle);
+            }
+            _ => {}
+        })
+        .invoke_handler(tauri::generate_handler![
+            // common
+            cmds::get_sys_proxy,
+            cmds::get_cur_proxy,
+            cmds::open_app_dir,
+            cmds::open_logs_dir,
+            cmds::kill_sidecar,
+            cmds::restart_sidecar,
+            // clash
+            cmds::get_clash_info,
+            cmds::patch_clash_config,
+            cmds::change_clash_core,
+            // verge
+            cmds::get_verge_config,
+            cmds::patch_verge_config,
+            // profile
+            cmds::view_profile,
+            cmds::patch_profile,
+            cmds::create_profile,
+            cmds::import_profile,
+            cmds::update_profile,
+            cmds::delete_profile,
+            cmds::select_profile,
+            cmds::get_profiles,
+            cmds::enhance_profiles,
+            cmds::change_profile_chain,
+            cmds::change_profile_valid,
+            cmds::read_profile_file,
+            cmds::save_profile_file,
+            // service mode
+            cmds::service::start_service,
+            cmds::service::stop_service,
+            cmds::service::check_service,
+            cmds::service::install_service,
+            cmds::service::uninstall_service,
+        ]);
+
+    #[cfg(target_os = "macos")]
+    {
+        use tauri::{Menu, MenuItem, Submenu};
+
+        let submenu_file = Submenu::new(
+            "File",
+            Menu::new()
+                .add_native_item(MenuItem::Undo)
+                .add_native_item(MenuItem::Redo)
+                .add_native_item(MenuItem::Copy)
+                .add_native_item(MenuItem::Paste)
+                .add_native_item(MenuItem::Cut)
+                .add_native_item(MenuItem::SelectAll),
+        );
+        builder = builder.menu(Menu::new().add_submenu(submenu_file));
+    }
+
+    builder
+        .build(tauri::generate_context!())
+        .expect("error while running tauri application")
+        .run(|app_handle, e| match e {
+            tauri::RunEvent::ExitRequested { api, .. } => {
+                api.prevent_exit();
+            }
+            tauri::RunEvent::Exit => {
+                resolve::resolve_reset(app_handle);
+                api::process::kill_children();
+            }
+            _ => {}
+        });
+
+    Ok(())
 }