refactor: wip

src-tauri/src/config/clash.rs

@@ -0,0 +1,180 @@
+use crate::utils::{config, dirs};
+use anyhow::Result;
+use once_cell::sync::OnceCell;
+use parking_lot::Mutex;
+use serde::{Deserialize, Serialize};
+use serde_yaml::{Mapping, Value};
+use std::sync::Arc;
+
+#[derive(Debug)]
+pub struct ClashN {
+    /// maintain the clash config
+    pub config: Arc<Mutex<Mapping>>,
+    /// some info
+    pub info: Arc<Mutex<ClashInfoN>>,
+}
+
+impl ClashN {
+    pub fn global() -> &'static ClashN {
+        static DATA: OnceCell<ClashN> = OnceCell::new();
+
+        DATA.get_or_init(|| {
+            let config = ClashN::read_config();
+            let info = ClashInfoN::from(&config);
+
+            ClashN {
+                config: Arc::new(Mutex::new(config)),
+                info: Arc::new(Mutex::new(info)),
+            }
+        })
+    }
+
+    /// get clash config
+    pub fn read_config() -> Mapping {
+        config::read_merge_mapping(dirs::clash_path())
+    }
+
+    /// save the clash config
+    pub fn save_config(&self) -> Result<()> {
+        let config = self.config.lock();
+
+        config::save_yaml(
+            dirs::clash_path(),
+            &*config,
+            Some("# Default Config For ClashN Core\n\n"),
+        )
+    }
+
+    /// 返回旧值
+    pub fn patch_info(&self, info: ClashInfoN) -> Result<ClashInfoN> {
+        let mut old_info = self.info.lock();
+        let old = (*old_info).to_owned();
+        *old_info = info;
+        Ok(old)
+    }
+
+    /// patch update the clash config
+    /// if the port is changed then return true
+    pub fn patch_config(&self, patch: Mapping) -> Result<()> {
+        let mut config = self.config.lock();
+
+        let port_key = Value::from("mixed-port");
+        let server_key = Value::from("external-controller");
+        let secret_key = Value::from("secret");
+
+        let change_info = patch.contains_key(&port_key)
+            || patch.contains_key(&server_key)
+            || patch.contains_key(&secret_key);
+
+        for (key, value) in patch.into_iter() {
+            config.insert(key, value);
+        }
+
+        if change_info {
+            let mut info = self.info.lock();
+            *info = ClashInfoN::from(&*config);
+        }
+
+        self.save_config()
+    }
+}
+
+#[derive(Default, Debug, Clone, Deserialize, Serialize)]
+pub struct ClashInfoN {
+    /// clash sidecar status
+    pub status: String,
+    /// clash core port
+    pub port: Option<String>,
+    /// same as `external-controller`
+    pub server: Option<String>,
+    /// clash secret
+    pub secret: Option<String>,
+}
+
+impl ClashInfoN {
+    /// parse the clash's config.yaml
+    /// get some information
+    pub fn from(config: &Mapping) -> ClashInfoN {
+        let key_port_1 = Value::from("mixed-port");
+        let key_port_2 = Value::from("port");
+        let key_server = Value::from("external-controller");
+        let key_secret = Value::from("secret");
+
+        let mut status: u32 = 0;
+
+        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()),
+                _ => {
+                    status |= 0b1;
+                    None
+                }
+            },
+            _ => {
+                status |= 0b10;
+                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()),
+                    _ => {
+                        status |= 0b100;
+                        None
+                    }
+                },
+                _ => {
+                    status |= 0b1000;
+                    None
+                }
+            },
+        };
+
+        // `external-controller` could be
+        // "127.0.0.1:9090" or ":9090"
+        let server = match config.get(&key_server) {
+            Some(value) => match value.as_str() {
+                Some(val_str) => {
+                    if val_str.starts_with(":") {
+                        Some(format!("127.0.0.1{val_str}"))
+                    } else if val_str.starts_with("0.0.0.0:") {
+                        Some(format!("127.0.0.1:{}", &val_str[8..]))
+                    } else if val_str.starts_with("[::]:") {
+                        Some(format!("127.0.0.1:{}", &val_str[5..]))
+                    } else {
+                        Some(val_str.into())
+                    }
+                }
+                None => {
+                    status |= 0b10000;
+                    None
+                }
+            },
+            None => {
+                status |= 0b100000;
+                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,
+        };
+
+        ClashInfoN {
+            status: format!("{status}"),
+            port,
+            server,
+            secret,
+        }
+    }
+}

src-tauri/src/config/field.rs

@@ -1,119 +0,0 @@
-use serde_yaml::{Mapping, Value};
-
-pub const HANDLE_FIELDS: [&str; 9] = [
-    "port",
-    "socks-port",
-    "mixed-port",
-    "mode",
-    "ipv6",
-    "log-level",
-    "allow-lan",
-    "external-controller",
-    "secret",
-];
-
-pub const DEFAULT_FIELDS: [&str; 5] = [
-    "proxies",
-    "proxy-groups",
-    "rules",
-    "proxy-providers",
-    "rule-providers",
-];
-
-pub const OTHERS_FIELDS: [&str; 21] = [
-    "tun",
-    "dns",
-    "ebpf",
-    "hosts",
-    "script",
-    "profile",
-    "payload",
-    "auto-redir",
-    "experimental",
-    "interface-name",
-    "routing-mark",
-    "redir-port",
-    "tproxy-port",
-    "iptables",
-    "external-ui",
-    "bind-address",
-    "authentication",
-    "sniffer",        // meta
-    "sub-rules",      // meta
-    "geodata-mode",   // meta
-    "tcp-concurrent", // meta
-];
-
-pub fn use_clash_fields() -> Vec<String> {
-    DEFAULT_FIELDS
-        .into_iter()
-        .chain(HANDLE_FIELDS)
-        .chain(OTHERS_FIELDS)
-        .map(|s| s.to_string())
-        .collect()
-}
-
-pub fn use_valid_fields(mut valid: Vec<String>) -> Vec<String> {
-    let others = Vec::from(OTHERS_FIELDS);
-
-    valid.iter_mut().for_each(|s| s.make_ascii_lowercase());
-    valid
-        .into_iter()
-        .filter(|s| others.contains(&s.as_str()))
-        .chain(DEFAULT_FIELDS.iter().map(|s| s.to_string()))
-        .collect()
-}
-
-pub fn use_filter(config: Mapping, filter: &Vec<String>) -> Mapping {
-    let mut ret = Mapping::new();
-
-    for (key, value) in config.into_iter() {
-        if let Some(key) = key.as_str() {
-            if filter.contains(&key.to_string()) {
-                ret.insert(Value::from(key), value);
-            }
-        }
-    }
-    ret
-}
-
-pub fn use_lowercase(config: Mapping) -> Mapping {
-    let mut ret = Mapping::new();
-
-    for (key, value) in config.into_iter() {
-        if let Some(key_str) = key.as_str() {
-            let mut key_str = String::from(key_str);
-            key_str.make_ascii_lowercase();
-            ret.insert(Value::from(key_str), value);
-        }
-    }
-    ret
-}
-
-pub fn use_sort(config: Mapping) -> Mapping {
-    let mut ret = Mapping::new();
-
-    HANDLE_FIELDS
-        .into_iter()
-        .chain(OTHERS_FIELDS)
-        .chain(DEFAULT_FIELDS)
-        .for_each(|key| {
-            let key = Value::from(key);
-            config.get(&key).map(|value| {
-                ret.insert(key, value.clone());
-            });
-        });
-    ret
-}
-
-pub fn use_keys(config: &Mapping) -> Vec<String> {
-    config
-        .iter()
-        .filter_map(|(key, _)| key.as_str())
-        .map(|s| {
-            let mut s = s.to_string();
-            s.make_ascii_lowercase();
-            return s;
-        })
-        .collect()
-}

src-tauri/src/config/merge.rs

@@ -1,93 +0,0 @@
-use super::{use_filter, use_lowercase};
-use serde_yaml::{self, Mapping, Sequence, Value};
-
-#[allow(unused)]
-const MERGE_FIELDS: [&str; 6] = [
-    "prepend-rules",
-    "append-rules",
-    "prepend-proxies",
-    "append-proxies",
-    "prepend-proxy-groups",
-    "append-proxy-groups",
-];
-
-pub fn use_merge(merge: Mapping, mut config: Mapping) -> Mapping {
-    // 直接覆盖原字段
-    use_lowercase(merge.clone())
-        .into_iter()
-        .for_each(|(key, value)| {
-            config.insert(key, value);
-        });
-
-    let merge_list = MERGE_FIELDS.iter().map(|s| s.to_string());
-    let merge = use_filter(merge, &merge_list.collect());
-
-    ["rules", "proxies", "proxy-groups"]
-        .iter()
-        .for_each(|key_str| {
-            let key_val = Value::from(key_str.to_string());
-
-            let mut list = Sequence::default();
-            list = config.get(&key_val).map_or(list.clone(), |val| {
-                val.as_sequence().map_or(list, |v| v.clone())
-            });
-
-            let pre_key = Value::from(format!("prepend-{key_str}"));
-            let post_key = Value::from(format!("append-{key_str}"));
-
-            if let Some(pre_val) = merge.get(&pre_key) {
-                if pre_val.is_sequence() {
-                    let mut pre_val = pre_val.as_sequence().unwrap().clone();
-                    pre_val.extend(list);
-                    list = pre_val;
-                }
-            }
-
-            if let Some(post_val) = merge.get(&post_key) {
-                if post_val.is_sequence() {
-                    list.extend(post_val.as_sequence().unwrap().clone());
-                }
-            }
-
-            config.insert(key_val, Value::from(list));
-        });
-    config
-}
-
-#[test]
-fn test_merge() -> anyhow::Result<()> {
-    let merge = r"
-    prepend-rules:
-      - prepend
-      - 1123123
-    append-rules:
-      - append
-    prepend-proxies:
-      - 9999
-    append-proxies:
-      - 1111
-    rules:
-      - replace
-    proxy-groups: 
-      - 123781923810
-    tun:
-      enable: true
-    dns:
-      enable: true
-  ";
-
-    let config = r"
-    rules:
-      - aaaaa
-    script1: test
-  ";
-
-    let merge = serde_yaml::from_str::<Mapping>(merge)?;
-    let config = serde_yaml::from_str::<Mapping>(config)?;
-
-    let result = serde_yaml::to_string(&use_merge(merge, config))?;
-
-    println!("{result}");
-
-    Ok(())
-}

src-tauri/src/config/mod.rs

@@ -1,69 +1,9 @@
-mod field;
-mod merge;
-mod script;
-mod tun;
+mod clash;
+mod prfitem;
+mod profiles;
+mod verge;
 
-pub(self) use self::field::*;
-use self::merge::*;
-use self::script::*;
-use self::tun::*;
-use crate::data::ChainItem;
-use crate::data::ChainType;
-use serde_yaml::Mapping;
-use std::collections::HashMap;
-use std::collections::HashSet;
-
-type ResultLog = Vec<(String, String)>;
-
-pub fn enhance_config(
-    clash_config: Mapping,
-    profile_config: Mapping,
-    chain: Vec<ChainItem>,
-    valid: Vec<String>,
-    tun_mode: bool,
-) -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
-    let mut config = profile_config;
-    let mut result_map = HashMap::new();
-    let mut exists_keys = use_keys(&config);
-
-    let valid = use_valid_fields(valid);
-
-    chain.into_iter().for_each(|item| match item.data {
-        ChainType::Merge(merge) => {
-            exists_keys.extend(use_keys(&merge));
-            config = use_merge(merge, config.to_owned());
-            config = use_filter(config.to_owned(), &valid);
-        }
-        ChainType::Script(script) => {
-            let mut logs = vec![];
-
-            match use_script(script, config.to_owned()) {
-                Ok((res_config, res_logs)) => {
-                    exists_keys.extend(use_keys(&res_config));
-                    config = use_filter(res_config, &valid);
-                    logs.extend(res_logs);
-                }
-                Err(err) => logs.push(("exception".into(), err.to_string())),
-            }
-
-            result_map.insert(item.uid, logs);
-        }
-    });
-
-    config = use_filter(config, &valid);
-
-    for (key, value) in clash_config.into_iter() {
-        config.insert(key, value);
-    }
-
-    let clash_fields = use_clash_fields();
-    config = use_filter(config, &clash_fields);
-    config = use_tun(config, tun_mode);
-    config = use_sort(config);
-
-    let mut exists_set = HashSet::new();
-    exists_set.extend(exists_keys.into_iter().filter(|s| clash_fields.contains(s)));
-    exists_keys = exists_set.into_iter().collect();
-
-    (config, exists_keys, result_map)
-}
+pub use self::clash::*;
+pub use self::prfitem::*;
+pub use self::profiles::*;
+pub use self::verge::*;

src-tauri/src/config/prfitem.rs

@@ -0,0 +1,406 @@
+use crate::utils::{config, dirs, help, tmpl};
+use anyhow::{bail, Context, Result};
+use reqwest::StatusCode;
+use serde::{Deserialize, Serialize};
+use serde_yaml::Mapping;
+use std::fs;
+use sysproxy::Sysproxy;
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct PrfItem {
+    pub uid: Option<String>,
+
+    /// profile item type
+    /// enum value: remote | local | script | merge
+    #[serde(rename = "type")]
+    pub itype: Option<String>,
+
+    /// profile name
+    pub name: Option<String>,
+
+    /// profile file
+    pub file: Option<String>,
+
+    /// profile description
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub desc: Option<String>,
+
+    /// source url
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub url: Option<String>,
+
+    /// selected information
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub selected: Option<Vec<PrfSelected>>,
+
+    /// subscription user info
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub extra: Option<PrfExtra>,
+
+    /// updated time
+    pub updated: Option<usize>,
+
+    /// some options of the item
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub option: Option<PrfOption>,
+
+    /// the file data
+    #[serde(skip)]
+    pub file_data: Option<String>,
+}
+
+#[derive(Default, Debug, Clone, Deserialize, Serialize)]
+pub struct PrfSelected {
+    pub name: Option<String>,
+    pub now: Option<String>,
+}
+
+#[derive(Default, Debug, Clone, Copy, Deserialize, Serialize)]
+pub struct PrfExtra {
+    pub upload: usize,
+    pub download: usize,
+    pub total: usize,
+    pub expire: usize,
+}
+
+#[derive(Default, Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
+pub struct PrfOption {
+    /// for `remote` profile's http request
+    /// see issue #13
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub user_agent: Option<String>,
+
+    /// for `remote` profile
+    /// use system proxy
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub with_proxy: Option<bool>,
+
+    /// for `remote` profile
+    /// use self proxy
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub self_proxy: Option<bool>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub update_interval: Option<u64>,
+}
+
+impl PrfOption {
+    pub fn merge(one: Option<Self>, other: Option<Self>) -> Option<Self> {
+        match (one, other) {
+            (Some(mut a), Some(b)) => {
+                a.user_agent = b.user_agent.or(a.user_agent);
+                a.with_proxy = b.with_proxy.or(a.with_proxy);
+                a.self_proxy = b.self_proxy.or(a.self_proxy);
+                a.update_interval = b.update_interval.or(a.update_interval);
+                Some(a)
+            }
+            t @ _ => t.0.or(t.1),
+        }
+    }
+}
+
+impl Default for PrfItem {
+    fn default() -> Self {
+        PrfItem {
+            uid: None,
+            itype: None,
+            name: None,
+            desc: None,
+            file: None,
+            url: None,
+            selected: None,
+            extra: None,
+            updated: None,
+            option: None,
+            file_data: None,
+        }
+    }
+}
+
+impl PrfItem {
+    /// From partial item
+    /// must contain `itype`
+    pub async fn from(item: PrfItem, file_data: Option<String>) -> Result<PrfItem> {
+        if item.itype.is_none() {
+            bail!("type should not be null");
+        }
+
+        match item.itype.unwrap().as_str() {
+            "remote" => {
+                if item.url.is_none() {
+                    bail!("url should not be null");
+                }
+                let url = item.url.as_ref().unwrap().as_str();
+                let name = item.name;
+                let desc = item.desc;
+                PrfItem::from_url(url, name, desc, item.option).await
+            }
+            "local" => {
+                let name = item.name.unwrap_or("Local File".into());
+                let desc = item.desc.unwrap_or("".into());
+                PrfItem::from_local(name, desc, file_data)
+            }
+            "merge" => {
+                let name = item.name.unwrap_or("Merge".into());
+                let desc = item.desc.unwrap_or("".into());
+                PrfItem::from_merge(name, desc)
+            }
+            "script" => {
+                let name = item.name.unwrap_or("Script".into());
+                let desc = item.desc.unwrap_or("".into());
+                PrfItem::from_script(name, desc)
+            }
+            typ @ _ => bail!("invalid profile item type \"{typ}\""),
+        }
+    }
+
+    /// ## Local type
+    /// create a new item from name/desc
+    pub fn from_local(name: String, desc: String, file_data: Option<String>) -> Result<PrfItem> {
+        let uid = help::get_uid("l");
+        let file = format!("{uid}.yaml");
+
+        Ok(PrfItem {
+            uid: Some(uid),
+            itype: Some("local".into()),
+            name: Some(name),
+            desc: Some(desc),
+            file: Some(file),
+            url: None,
+            selected: None,
+            extra: None,
+            option: None,
+            updated: Some(help::get_now()),
+            file_data: Some(file_data.unwrap_or(tmpl::ITEM_LOCAL.into())),
+        })
+    }
+
+    /// ## Remote type
+    /// create a new item from url
+    pub async fn from_url(
+        url: &str,
+        name: Option<String>,
+        desc: Option<String>,
+        option: Option<PrfOption>,
+    ) -> Result<PrfItem> {
+        let opt_ref = option.as_ref();
+        let with_proxy = opt_ref.map_or(false, |o| o.with_proxy.unwrap_or(false));
+        let self_proxy = opt_ref.map_or(false, |o| o.self_proxy.unwrap_or(false));
+        let user_agent = opt_ref.map_or(None, |o| o.user_agent.clone());
+
+        let mut builder = reqwest::ClientBuilder::new().no_proxy();
+
+        // 使用软件自己的代理
+        if self_proxy {
+            let clash = super::ClashN::global();
+            let port = clash.info.lock().port.clone();
+            let port = port.ok_or(anyhow::anyhow!("failed to get clash info port"))?;
+            let proxy_scheme = format!("http://127.0.0.1:{port}");
+
+            if let Ok(proxy) = reqwest::Proxy::http(&proxy_scheme) {
+                builder = builder.proxy(proxy);
+            }
+            if let Ok(proxy) = reqwest::Proxy::https(&proxy_scheme) {
+                builder = builder.proxy(proxy);
+            }
+            if let Ok(proxy) = reqwest::Proxy::all(&proxy_scheme) {
+                builder = builder.proxy(proxy);
+            }
+        }
+        // 使用系统代理
+        else if with_proxy {
+            match Sysproxy::get_system_proxy() {
+                Ok(p @ Sysproxy { enable: true, .. }) => {
+                    let proxy_scheme = format!("http://{}:{}", p.host, p.port);
+
+                    if let Ok(proxy) = reqwest::Proxy::http(&proxy_scheme) {
+                        builder = builder.proxy(proxy);
+                    }
+                    if let Ok(proxy) = reqwest::Proxy::https(&proxy_scheme) {
+                        builder = builder.proxy(proxy);
+                    }
+                    if let Ok(proxy) = reqwest::Proxy::all(&proxy_scheme) {
+                        builder = builder.proxy(proxy);
+                    }
+                }
+                _ => {}
+            };
+        }
+
+        let version = unsafe { dirs::APP_VERSION };
+        let version = format!("clash-verge/{version}");
+        builder = builder.user_agent(user_agent.unwrap_or(version));
+
+        let resp = builder.build()?.get(url).send().await?;
+
+        let status_code = resp.status();
+        if !StatusCode::is_success(&status_code) {
+            bail!("failed to fetch remote profile with status {status_code}")
+        }
+
+        let header = resp.headers();
+
+        // parse the Subscription UserInfo
+        let extra = match header.get("Subscription-Userinfo") {
+            Some(value) => {
+                let sub_info = value.to_str().unwrap_or("");
+
+                Some(PrfExtra {
+                    upload: help::parse_str(sub_info, "upload=").unwrap_or(0),
+                    download: help::parse_str(sub_info, "download=").unwrap_or(0),
+                    total: help::parse_str(sub_info, "total=").unwrap_or(0),
+                    expire: help::parse_str(sub_info, "expire=").unwrap_or(0),
+                })
+            }
+            None => None,
+        };
+
+        // parse the Content-Disposition
+        let filename = match header.get("Content-Disposition") {
+            Some(value) => {
+                let filename = value.to_str().unwrap_or("");
+                help::parse_str::<String>(filename, "filename=")
+            }
+            None => None,
+        };
+
+        // parse the profile-update-interval
+        let option = match header.get("profile-update-interval") {
+            Some(value) => match value.to_str().unwrap_or("").parse::<u64>() {
+                Ok(val) => Some(PrfOption {
+                    update_interval: Some(val * 60), // hour -> min
+                    ..PrfOption::default()
+                }),
+                Err(_) => None,
+            },
+            None => None,
+        };
+
+        let uid = help::get_uid("r");
+        let file = format!("{uid}.yaml");
+        let name = name.unwrap_or(filename.unwrap_or("Remote File".into()));
+        let data = resp.text_with_charset("utf-8").await?;
+
+        // check the data whether the valid yaml format
+        let yaml = serde_yaml::from_str::<Mapping>(&data) //
+            .context("the remote profile data is invalid yaml")?;
+
+        if !yaml.contains_key("proxies") && !yaml.contains_key("proxy-providers") {
+            bail!("profile does not contain `proxies` or `proxy-providers`");
+        }
+
+        Ok(PrfItem {
+            uid: Some(uid),
+            itype: Some("remote".into()),
+            name: Some(name),
+            desc,
+            file: Some(file),
+            url: Some(url.into()),
+            selected: None,
+            extra,
+            option,
+            updated: Some(help::get_now()),
+            file_data: Some(data),
+        })
+    }
+
+    /// ## Merge type (enhance)
+    /// create the enhanced item by using `merge` rule
+    pub fn from_merge(name: String, desc: String) -> Result<PrfItem> {
+        let uid = help::get_uid("m");
+        let file = format!("{uid}.yaml");
+
+        Ok(PrfItem {
+            uid: Some(uid),
+            itype: Some("merge".into()),
+            name: Some(name),
+            desc: Some(desc),
+            file: Some(file),
+            url: None,
+            selected: None,
+            extra: None,
+            option: None,
+            updated: Some(help::get_now()),
+            file_data: Some(tmpl::ITEM_MERGE.into()),
+        })
+    }
+
+    /// ## Script type (enhance)
+    /// create the enhanced item by using javascript quick.js
+    pub fn from_script(name: String, desc: String) -> Result<PrfItem> {
+        let uid = help::get_uid("s");
+        let file = format!("{uid}.js"); // js ext
+
+        Ok(PrfItem {
+            uid: Some(uid),
+            itype: Some("script".into()),
+            name: Some(name),
+            desc: Some(desc),
+            file: Some(file),
+            url: None,
+            selected: None,
+            extra: None,
+            option: None,
+            updated: Some(help::get_now()),
+            file_data: Some(tmpl::ITEM_SCRIPT.into()),
+        })
+    }
+
+    /// get the file data
+    pub fn read_file(&self) -> Result<String> {
+        if self.file.is_none() {
+            bail!("could not find the file");
+        }
+
+        let file = self.file.clone().unwrap();
+        let path = dirs::app_profiles_dir().join(file);
+        fs::read_to_string(path).context("failed to read the file")
+    }
+
+    /// save the file data
+    pub fn save_file(&self, data: String) -> Result<()> {
+        if self.file.is_none() {
+            bail!("could not find the file");
+        }
+
+        let file = self.file.clone().unwrap();
+        let path = dirs::app_profiles_dir().join(file);
+        fs::write(path, data.as_bytes()).context("failed to save the file")
+    }
+
+    /// get the data for enhanced mode
+    pub fn to_enhance(&self) -> Option<ChainItem> {
+        let itype = self.itype.as_ref()?.as_str();
+        let file = self.file.clone()?;
+        let uid = self.uid.clone().unwrap_or("".into());
+        let path = dirs::app_profiles_dir().join(file);
+
+        if !path.exists() {
+            return None;
+        }
+
+        match itype {
+            "script" => Some(ChainItem {
+                uid,
+                data: ChainType::Script(fs::read_to_string(path).unwrap_or("".into())),
+            }),
+            "merge" => Some(ChainItem {
+                uid,
+                data: ChainType::Merge(config::read_merge_mapping(path)),
+            }),
+            _ => None,
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct ChainItem {
+    pub uid: String,
+    pub data: ChainType,
+}
+
+#[derive(Debug, Clone)]
+pub enum ChainType {
+    Merge(Mapping),
+    Script(String),
+}

src-tauri/src/config/profiles.rs

@@ -0,0 +1,379 @@
+use super::{prfitem::PrfItem, ChainItem, PrfOption};
+use crate::{
+    core::CoreManager,
+    utils::{config, dirs, help},
+};
+use anyhow::{bail, Context, Result};
+use once_cell::sync::OnceCell;
+use parking_lot::Mutex;
+use serde::{Deserialize, Serialize};
+use serde_yaml::Mapping;
+use std::collections::HashMap;
+use std::sync::Arc;
+use std::{fs, io::Write};
+
+pub struct ProfilesN {
+    pub config: Arc<Mutex<IProfiles>>,
+}
+
+impl ProfilesN {
+    pub fn global() -> &'static ProfilesN {
+        static PROFILES: OnceCell<ProfilesN> = OnceCell::new();
+
+        PROFILES.get_or_init(|| ProfilesN {
+            config: Arc::new(Mutex::new(IProfiles::read_file())),
+        })
+    }
+
+    /// 更新单个配置
+    pub async fn update_item(&self, uid: String, option: Option<PrfOption>) -> Result<()> {
+        let (url, opt) = {
+            let profiles = self.config.lock();
+            let item = profiles.get_item(&uid)?;
+
+            if let Some(typ) = item.itype.as_ref() {
+                // maybe only valid for `local` profile
+                if *typ != "remote" {
+                    // reactivate the config
+                    if Some(uid) == profiles.get_current() {
+                        drop(profiles);
+                        tauri::async_runtime::block_on(async {
+                            CoreManager::global().activate_config().await
+                        })?;
+                    }
+                    return Ok(());
+                }
+            }
+            if item.url.is_none() {
+                bail!("failed to get the profile item url");
+            }
+            (item.url.clone().unwrap(), item.option.clone())
+        };
+
+        let merged_opt = PrfOption::merge(opt, option);
+        let item = PrfItem::from_url(&url, None, None, merged_opt).await?;
+
+        let mut profiles = self.config.lock();
+        profiles.update_item(uid.clone(), item)?;
+
+        // reactivate the profile
+        if Some(uid) == profiles.get_current() {
+            drop(profiles);
+            tauri::async_runtime::block_on(async {
+                CoreManager::global().activate_config().await
+            })?;
+        }
+
+        Ok(())
+    }
+}
+
+/// Define the `profiles.yaml` schema
+#[derive(Default, Debug, Clone, Deserialize, Serialize)]
+pub struct IProfiles {
+    /// same as PrfConfig.current
+    current: Option<String>,
+
+    /// same as PrfConfig.chain
+    chain: Option<Vec<String>>,
+
+    /// record valid fields for clash
+    valid: Option<Vec<String>>,
+
+    /// profile list
+    items: Option<Vec<PrfItem>>,
+}
+
+macro_rules! patch {
+    ($lv: expr, $rv: expr, $key: tt) => {
+        if ($rv.$key).is_some() {
+            $lv.$key = $rv.$key;
+        }
+    };
+}
+
+impl IProfiles {
+    /// read the config from the file
+    pub fn read_file() -> Self {
+        let mut profiles = config::read_yaml::<Self>(dirs::profiles_path());
+        if profiles.items.is_none() {
+            profiles.items = Some(vec![]);
+        }
+        // compatible with the old old old version
+        profiles.items.as_mut().map(|items| {
+            for mut item in items.iter_mut() {
+                if item.uid.is_none() {
+                    item.uid = Some(help::get_uid("d"));
+                }
+            }
+        });
+        profiles
+    }
+
+    /// save the config to the file
+    pub fn save_file(&self) -> Result<()> {
+        config::save_yaml(
+            dirs::profiles_path(),
+            self,
+            Some("# Profiles Config for Clash Verge\n\n"),
+        )
+    }
+
+    /// get the current uid
+    pub fn get_current(&self) -> Option<String> {
+        self.current.clone()
+    }
+
+    /// only change the main to the target id
+    pub fn put_current(&mut self, uid: String) -> Result<()> {
+        if self.items.is_none() {
+            self.items = Some(vec![]);
+        }
+
+        let items = self.items.as_ref().unwrap();
+        let some_uid = Some(uid.clone());
+
+        if items.iter().find(|&each| each.uid == some_uid).is_some() {
+            self.current = some_uid;
+            return self.save_file();
+        }
+
+        bail!("invalid uid \"{uid}\"");
+    }
+
+    /// just change the `chain`
+    pub fn put_chain(&mut self, chain: Option<Vec<String>>) -> Result<()> {
+        self.chain = chain;
+        self.save_file()
+    }
+
+    /// just change the `field`
+    pub fn put_valid(&mut self, valid: Option<Vec<String>>) -> Result<()> {
+        self.valid = valid;
+        self.save_file()
+    }
+
+    /// get items ref
+    pub fn get_items(&self) -> Option<&Vec<PrfItem>> {
+        self.items.as_ref()
+    }
+
+    /// find the item by the uid
+    pub fn get_item(&self, uid: &String) -> Result<&PrfItem> {
+        if self.items.is_some() {
+            let items = self.items.as_ref().unwrap();
+            let some_uid = Some(uid.clone());
+
+            for each in items.iter() {
+                if each.uid == some_uid {
+                    return Ok(each);
+                }
+            }
+        }
+
+        bail!("failed to get the profile item \"uid:{uid}\"");
+    }
+
+    /// append new item
+    /// if the file_data is some
+    /// then should save the data to file
+    pub fn append_item(&mut self, mut item: PrfItem) -> Result<()> {
+        if item.uid.is_none() {
+            bail!("the uid should not be null");
+        }
+
+        // save the file data
+        // move the field value after save
+        if let Some(file_data) = item.file_data.take() {
+            if item.file.is_none() {
+                bail!("the file should not be null");
+            }
+
+            let file = item.file.clone().unwrap();
+            let path = dirs::app_profiles_dir().join(&file);
+
+            fs::File::create(path)
+                .context(format!("failed to create file \"{}\"", file))?
+                .write(file_data.as_bytes())
+                .context(format!("failed to write to file \"{}\"", file))?;
+        }
+
+        if self.items.is_none() {
+            self.items = Some(vec![]);
+        }
+
+        self.items.as_mut().map(|items| items.push(item));
+        self.save_file()
+    }
+
+    /// update the item value
+    pub fn patch_item(&mut self, uid: String, item: PrfItem) -> Result<()> {
+        let mut items = self.items.take().unwrap_or(vec![]);
+
+        for mut each in items.iter_mut() {
+            if each.uid == Some(uid.clone()) {
+                patch!(each, item, itype);
+                patch!(each, item, name);
+                patch!(each, item, desc);
+                patch!(each, item, file);
+                patch!(each, item, url);
+                patch!(each, item, selected);
+                patch!(each, item, extra);
+                patch!(each, item, updated);
+                patch!(each, item, option);
+
+                self.items = Some(items);
+                return self.save_file();
+            }
+        }
+
+        self.items = Some(items);
+        bail!("failed to find the profile item \"uid:{uid}\"")
+    }
+
+    /// be used to update the remote item
+    /// only patch `updated` `extra` `file_data`
+    pub fn update_item(&mut self, uid: String, mut item: PrfItem) -> Result<()> {
+        if self.items.is_none() {
+            self.items = Some(vec![]);
+        }
+
+        // find the item
+        let _ = self.get_item(&uid)?;
+
+        if let Some(items) = self.items.as_mut() {
+            let some_uid = Some(uid.clone());
+
+            for mut each in items.iter_mut() {
+                if each.uid == some_uid {
+                    each.extra = item.extra;
+                    each.updated = item.updated;
+
+                    // save the file data
+                    // move the field value after save
+                    if let Some(file_data) = item.file_data.take() {
+                        let file = each.file.take();
+                        let file =
+                            file.unwrap_or(item.file.take().unwrap_or(format!("{}.yaml", &uid)));
+
+                        // the file must exists
+                        each.file = Some(file.clone());
+
+                        let path = dirs::app_profiles_dir().join(&file);
+
+                        fs::File::create(path)
+                            .context(format!("failed to create file \"{}\"", file))?
+                            .write(file_data.as_bytes())
+                            .context(format!("failed to write to file \"{}\"", file))?;
+                    }
+
+                    break;
+                }
+            }
+        }
+
+        self.save_file()
+    }
+
+    /// delete item
+    /// if delete the current then return true
+    pub fn delete_item(&mut self, uid: String) -> Result<bool> {
+        let current = self.current.as_ref().unwrap_or(&uid);
+        let current = current.clone();
+
+        let mut items = self.items.take().unwrap_or(vec![]);
+        let mut index = None;
+
+        // get the index
+        for i in 0..items.len() {
+            if items[i].uid == Some(uid.clone()) {
+                index = Some(i);
+                break;
+            }
+        }
+
+        if let Some(index) = index {
+            items.remove(index).file.map(|file| {
+                let path = dirs::app_profiles_dir().join(file);
+                if path.exists() {
+                    let _ = fs::remove_file(path);
+                }
+            });
+        }
+
+        // delete the original uid
+        if current == uid {
+            self.current = match items.len() > 0 {
+                true => items[0].uid.clone(),
+                false => None,
+            };
+        }
+
+        self.items = Some(items);
+        self.save_file()?;
+        Ok(current == uid)
+    }
+
+    /// generate the current Mapping data
+    fn gen_current(&self) -> Result<Mapping> {
+        let config = Mapping::new();
+
+        if self.current.is_none() || self.items.is_none() {
+            return Ok(config);
+        }
+
+        let current = self.current.clone().unwrap();
+        for item in self.items.as_ref().unwrap().iter() {
+            if item.uid == Some(current.clone()) {
+                let file_path = match item.file.clone() {
+                    Some(file) => dirs::app_profiles_dir().join(file),
+                    None => bail!("failed to get the file field"),
+                };
+
+                if !file_path.exists() {
+                    bail!("failed to read the file \"{}\"", file_path.display());
+                }
+
+                return Ok(config::read_merge_mapping(file_path.clone()));
+            }
+        }
+        bail!("failed to find current profile \"uid:{current}\"");
+    }
+
+    /// generate the data for activate clash config
+    pub fn gen_activate(&self) -> Result<PrfActivate> {
+        let current = self.gen_current()?;
+        let chain = match self.chain.as_ref() {
+            Some(chain) => chain
+                .iter()
+                .filter_map(|uid| self.get_item(uid).ok())
+                .filter_map(|item| item.to_enhance())
+                .collect::<Vec<ChainItem>>(),
+            None => vec![],
+        };
+        let valid = self.valid.clone().unwrap_or(vec![]);
+
+        Ok(PrfActivate {
+            current,
+            chain,
+            valid,
+        })
+    }
+}
+
+#[derive(Default, Clone)]
+pub struct PrfActivate {
+    pub current: Mapping,
+    pub chain: Vec<ChainItem>,
+    pub valid: Vec<String>,
+}
+
+#[derive(Default, Debug, Clone, Deserialize, Serialize)]
+pub struct RuntimeResult {
+    pub config: Option<Mapping>,
+    pub config_yaml: Option<String>,
+    // 记录在配置中（包括merge和script生成的）出现过的keys
+    // 这些keys不一定都生效
+    pub exists_keys: Vec<String>,
+    pub chain_logs: HashMap<String, Vec<(String, String)>>,
+}

src-tauri/src/config/script.rs

@@ -1,94 +0,0 @@
-use super::use_lowercase;
-use anyhow::Result;
-use serde_yaml::Mapping;
-
-pub fn use_script(script: String, config: Mapping) -> Result<(Mapping, Vec<(String, String)>)> {
-    use rquickjs::{Context, Func, Runtime};
-    use std::sync::{Arc, Mutex};
-
-    let runtime = Runtime::new().unwrap();
-    let context = Context::full(&runtime).unwrap();
-    let outputs = Arc::new(Mutex::new(vec![]));
-
-    let copy_outputs = outputs.clone();
-    let result = context.with(|ctx| -> Result<Mapping> {
-        ctx.globals().set(
-            "__verge_log__",
-            Func::from(move |level: String, data: String| {
-                let mut out = copy_outputs.lock().unwrap();
-                out.push((level, data));
-            }),
-        )?;
-
-        ctx.eval(
-            r#"var console = Object.freeze({
-        log(data){__verge_log__("log",JSON.stringify(data))}, 
-        info(data){__verge_log__("info",JSON.stringify(data))}, 
-        error(data){__verge_log__("error",JSON.stringify(data))},
-        debug(data){__verge_log__("debug",JSON.stringify(data))},
-      });"#,
-        )?;
-
-        let config = use_lowercase(config.clone());
-        let config_str = serde_json::to_string(&config)?;
-
-        let code = format!(
-            r#"try{{
-        {script};
-        JSON.stringify(main({config_str})||'')
-      }} catch(err) {{
-        `__error_flag__ ${{err.toString()}}`
-      }}"#
-        );
-        let result: String = ctx.eval(code.as_str())?;
-        if result.starts_with("__error_flag__") {
-            anyhow::bail!(result[15..].to_owned());
-        }
-        if result == "\"\"" {
-            anyhow::bail!("main function should return object");
-        }
-        return Ok(serde_json::from_str::<Mapping>(result.as_str())?);
-    });
-
-    let mut out = outputs.lock().unwrap();
-    match result {
-        Ok(config) => Ok((use_lowercase(config), out.to_vec())),
-        Err(err) => {
-            out.push(("exception".into(), err.to_string()));
-            Ok((config, out.to_vec()))
-        }
-    }
-}
-
-#[test]
-fn test_script() {
-    let script = r#"
-    function main(config) {
-      if (Array.isArray(config.rules)) {
-        config.rules = [...config.rules, "add"];
-      }
-      console.log(config);
-      config.proxies = ["111"];
-      return config;
-    }
-  "#;
-
-    let config = r#"
-    rules:
-      - 111
-      - 222
-    tun:
-      enable: false
-    dns:
-      enable: false
-  "#;
-
-    let config = serde_yaml::from_str(config).unwrap();
-    let (config, results) = use_script(script.into(), config).unwrap();
-
-    let config_str = serde_yaml::to_string(&config).unwrap();
-
-    println!("{config_str}");
-
-    dbg!(results);
-}

src-tauri/src/config/tun.rs

@@ -1,81 +0,0 @@
-use serde_yaml::{Mapping, Value};
-
-macro_rules! revise {
-    ($map: expr, $key: expr, $val: expr) => {
-        let ret_key = Value::String($key.into());
-        $map.insert(ret_key, Value::from($val));
-    };
-}
-
-// 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));
-        }
-    };
-}
-
-pub fn use_tun(mut config: Mapping, enable: bool) -> Mapping {
-    let tun_key = Value::from("tun");
-    let tun_val = config.get(&tun_key);
-
-    if !enable && tun_val.is_none() {
-        return config;
-    }
-
-    let mut tun_val = tun_val.map_or(Mapping::new(), |val| {
-        val.as_mapping().cloned().unwrap_or(Mapping::new())
-    });
-
-    revise!(tun_val, "enable", enable);
-    if enable {
-        append!(tun_val, "stack", "gvisor");
-        append!(tun_val, "dns-hijack", vec!["any:53"]);
-        append!(tun_val, "auto-route", true);
-        append!(tun_val, "auto-detect-interface", true);
-    }
-
-    revise!(config, "tun", tun_val);
-
-    if enable {
-        use_dns_for_tun(config)
-    } else {
-        config
-    }
-}
-
-fn use_dns_for_tun(mut config: Mapping) -> Mapping {
-    let dns_key = Value::from("dns");
-    let dns_val = config.get(&dns_key);
-
-    let mut dns_val = dns_val.map_or(Mapping::new(), |val| {
-        val.as_mapping().cloned().unwrap_or(Mapping::new())
-    });
-
-    // 开启tun将同时开启dns
-    revise!(dns_val, "enable", true);
-
-    append!(dns_val, "enhanced-mode", "fake-ip");
-    append!(dns_val, "fake-ip-range", "198.18.0.1/16");
-    append!(
-        dns_val,
-        "nameserver",
-        vec!["114.114.114.114", "223.5.5.5", "8.8.8.8"]
-    );
-    append!(dns_val, "fallback", vec![] as Vec<&str>);
-
-    #[cfg(target_os = "windows")]
-    append!(
-        dns_val,
-        "fake-ip-filter",
-        vec![
-            "dns.msftncsi.com",
-            "www.msftncsi.com",
-            "www.msftconnecttest.com"
-        ]
-    );
-    revise!(config, "dns", dns_val);
-    config
-}

src-tauri/src/config/verge.rs

@@ -0,0 +1,166 @@
+use crate::utils::{config, dirs};
+use anyhow::Result;
+use once_cell::sync::OnceCell;
+use parking_lot::Mutex;
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+
+pub struct VergeN {
+    pub config: Arc<Mutex<IVerge>>,
+}
+
+impl VergeN {
+    pub fn global() -> &'static VergeN {
+        static DATA: OnceCell<VergeN> = OnceCell::new();
+
+        DATA.get_or_init(|| {
+            let config = config::read_yaml::<IVerge>(dirs::verge_path());
+            VergeN {
+                config: Arc::new(Mutex::new(config)),
+            }
+        })
+    }
+
+    /// Save IVerge App Config
+    pub fn save_file(&self) -> Result<()> {
+        let config = self.config.lock();
+
+        config::save_yaml(
+            dirs::verge_path(),
+            &*config,
+            Some("# The Config for Clash IVerge App\n\n"),
+        )
+    }
+
+    /// patch verge config
+    /// only save to file
+    pub fn patch_config(&self, patch: IVerge) -> Result<()> {
+        let mut config = self.config.lock();
+
+        macro_rules! patch {
+            ($key: tt) => {
+                if patch.$key.is_some() {
+                    config.$key = patch.$key;
+                }
+            };
+        }
+
+        patch!(language);
+        patch!(theme_mode);
+        patch!(theme_blur);
+        patch!(traffic_graph);
+
+        patch!(enable_tun_mode);
+        patch!(enable_service_mode);
+        patch!(enable_auto_launch);
+        patch!(enable_silent_start);
+        patch!(enable_system_proxy);
+        patch!(enable_proxy_guard);
+        patch!(system_proxy_bypass);
+        patch!(proxy_guard_duration);
+
+        patch!(theme_setting);
+        patch!(web_ui_list);
+        patch!(clash_core);
+        patch!(hotkeys);
+
+        patch!(auto_close_connection);
+        patch!(default_latency_test);
+
+        self.save_file()
+    }
+
+    /// 在初始化前尝试拿到单例端口的值
+    pub fn get_singleton_port() -> u16 {
+        let config = config::read_yaml::<IVerge>(dirs::verge_path());
+
+        #[cfg(not(feature = "verge-dev"))]
+        const SERVER_PORT: u16 = 33331;
+        #[cfg(feature = "verge-dev")]
+        const SERVER_PORT: u16 = 11233;
+
+        config.app_singleton_port.unwrap_or(SERVER_PORT)
+    }
+}
+
+/// ### `verge.yaml` schema
+#[derive(Default, Debug, Clone, Deserialize, Serialize)]
+pub struct IVerge {
+    /// app listening port
+    /// for app singleton
+    pub app_singleton_port: Option<u16>,
+
+    // i18n
+    pub language: Option<String>,
+
+    /// `light` or `dark` or `system`
+    pub theme_mode: Option<String>,
+
+    /// enable blur mode
+    /// maybe be able to set the alpha
+    pub theme_blur: Option<bool>,
+
+    /// enable traffic graph default is true
+    pub traffic_graph: Option<bool>,
+
+    /// 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>,
+
+    /// not show the window on launch
+    pub enable_silent_start: Option<bool>,
+
+    /// set system proxy
+    pub enable_system_proxy: Option<bool>,
+
+    /// enable proxy guard
+    pub enable_proxy_guard: Option<bool>,
+
+    /// set system proxy bypass
+    pub system_proxy_bypass: Option<String>,
+
+    /// proxy guard duration
+    pub proxy_guard_duration: Option<u64>,
+
+    /// theme setting
+    pub theme_setting: Option<IVergeTheme>,
+
+    /// web ui list
+    pub web_ui_list: Option<Vec<String>>,
+
+    /// clash core path
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub clash_core: Option<String>,
+
+    /// hotkey map
+    /// format: {func},{key}
+    pub hotkeys: Option<Vec<String>>,
+
+    /// 切换代理时自动关闭连接
+    pub auto_close_connection: Option<bool>,
+
+    /// 默认的延迟测试连接
+    pub default_latency_test: Option<String>,
+}
+
+#[derive(Default, Debug, Clone, Deserialize, Serialize)]
+pub struct IVergeTheme {
+    pub primary_color: Option<String>,
+    pub secondary_color: Option<String>,
+    pub primary_text: Option<String>,
+    pub secondary_text: Option<String>,
+
+    pub info_color: Option<String>,
+    pub error_color: Option<String>,
+    pub warning_color: Option<String>,
+    pub success_color: Option<String>,
+
+    pub font_family: Option<String>,
+    pub css_injection: Option<String>,
+}