v0.0.16

feat: change window style
feat: fill verge template
2022-02-21 01:33:11 +08:00 · 2022-02-20 23:46:13 +08:00 · 2022-02-20 20:12:55 +08:00 · 2022-02-20 20:11:39 +08:00 · 2022-02-20 18:53:21 +08:00 · 2022-02-19 18:14:40 +08:00
58 changed files with 3312 additions and 4330 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -48,7 +48,9 @@ jobs:
            ${{ runner.os }}-yarn-

      - name: Yarn install and check
-        run: yarn && yarn run check
+        run: |
+          yarn install --network-timeout 1000000
+          yarn run check

      - name: Tauri build
        uses: tauri-apps/tauri-action@v0
@@ -56,9 +58,43 @@ jobs:
        continue-on-error: true
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          TAURI_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
+          TAURI_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
        with:
          tagName: v__VERSION__
          releaseName: "Clash Verge v__VERSION__"
          releaseBody: "Clash Verge now supports Windows and macos(intel)."
          releaseDraft: false
          prerelease: true
+
+  release-update:
+    needs: release
+    runs-on: macos-11
+    if: |
+      startsWith(github.repository, 'zzzgydi') &&
+      startsWith(github.ref, 'refs/tags/v')
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v2
+
+      - name: Get yarn cache dir path
+        id: yarn-cache-dir-path
+        run: echo "::set-output name=dir::$(yarn cache dir)"
+
+      - name: Yarn Cache
+        uses: actions/cache@v2
+        id: yarn-cache
+        with:
+          path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
+          key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-yarn-
+
+      - name: Yarn install
+        run: yarn
+
+      - name: Release update.json
+        run: yarn run release
+        continue-on-error: true
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
--- a/README.md
+++ b/README.md
@@ -58,6 +58,15 @@ This is a learning project for Rust practice.

 PR welcome!

+## Acknowledgement
+
+Clash Verge was based on or inspired by these projects and so on:
+
+- [tauri-apps/tauri](https://github.com/tauri-apps/tauri): Build smaller, faster, and more secure desktop applications with a web frontend.
+- [Dreamacro/clash](https://github.com/Dreamacro/clash): A rule-based tunnel in Go.
+- [Fndroid/clash_for_windows_pkg](https://github.com/Fndroid/clash_for_windows_pkg): A Windows/macOS GUI based on Clash.
+- [vitejs/vite](https://github.com/vitejs/vite): Next generation frontend tooling. It's fast!
+
 ## License

-GPL-3.0 License
+GPL-3.0 License. See [License here](./LICENSE) for details.
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
  "name": "clash-verge",
-  "version": "0.0.11",
+  "version": "0.0.16",
  "license": "GPL-3.0",
  "scripts": {
    "dev": "cargo tauri dev",
@@ -11,37 +11,41 @@
    "web:serve": "vite preview",
    "check": "node scripts/check.mjs",
    "publish": "node scripts/publish.mjs",
+    "release": "node scripts/release.mjs",
    "prepare": "husky install"
  },
  "dependencies": {
    "@emotion/react": "^11.7.0",
    "@emotion/styled": "^11.6.0",
-    "@mui/icons-material": "^5.2.1",
-    "@mui/material": "^5.2.3",
-    "@tauri-apps/api": "^1.0.0-beta.8",
-    "axios": "^0.24.0",
+    "@mui/icons-material": "^5.4.1",
+    "@mui/material": "^5.4.1",
+    "@tauri-apps/api": "^1.0.0-rc.1",
+    "ahooks": "^3.1.9",
+    "axios": "^0.26.0",
    "dayjs": "^1.10.7",
-    "react": "^17.0.0",
-    "react-dom": "^17.0.0",
-    "react-router-dom": "^6.0.2",
-    "react-virtuoso": "^2.3.1",
-    "recoil": "^0.5.2",
-    "swr": "^1.1.2-beta.0"
+    "react": "^17.0.2",
+    "react-dom": "^17.0.2",
+    "react-router-dom": "^6.2.1",
+    "react-virtuoso": "^2.7.0",
+    "recoil": "^0.6.1",
+    "swr": "^1.2.1"
  },
  "devDependencies": {
-    "@tauri-apps/cli": "^1.0.0-beta.10",
+    "@actions/github": "^5.0.0",
+    "@tauri-apps/cli": "^1.0.0-rc.5",
    "@types/fs-extra": "^9.0.13",
+    "@types/js-cookie": "^3.0.1",
    "@types/react": "^17.0.0",
    "@types/react-dom": "^17.0.0",
-    "@vitejs/plugin-react": "^1.1.1",
+    "@vitejs/plugin-react": "^1.2.0",
    "adm-zip": "^0.5.9",
    "fs-extra": "^10.0.0",
    "husky": "^7.0.0",
-    "node-fetch": "^3.1.0",
+    "node-fetch": "^3.2.0",
    "pretty-quick": "^3.1.3",
-    "sass": "^1.44.0",
-    "typescript": "^4.5.2",
-    "vite": "^2.7.1"
+    "sass": "^1.49.7",
+    "typescript": "^4.5.5",
+    "vite": "^2.8.0"
  },
  "prettier": {
    "tabWidth": 2,
--- a/scripts/check.mjs
+++ b/scripts/check.mjs
@@ -9,7 +9,7 @@ const cwd = process.cwd();

 const CLASH_URL_PREFIX =
  "https://github.com/Dreamacro/clash/releases/download/premium/";
-const CLASH_LATEST_DATE = "2022.01.03";
+const CLASH_LATEST_DATE = "2022.01.27";

 /**
 * get the correct clash release infomation
@@ -50,7 +50,7 @@ async function resolveSidecar() {
  const sidecarFile = `clash-${host}${ext}`;
  const sidecarPath = path.join(sidecarDir, sidecarFile);

-  if (!(await fs.pathExists(sidecarDir))) await fs.mkdir(sidecarDir);
+  await fs.mkdirp(sidecarDir);
  if (await fs.pathExists(sidecarPath)) return;

  // download sidecar
@@ -59,7 +59,7 @@ async function resolveSidecar() {
  const tempZip = path.join(tempDir, binInfo.zipfile);
  const tempExe = path.join(tempDir, binInfo.exefile);

-  if (!(await fs.pathExists(tempDir))) await fs.mkdir(tempDir);
+  await fs.mkdirp(tempDir);
  if (!(await fs.pathExists(tempZip))) await downloadFile(binInfo.url, tempZip);

  if (binInfo.zip === "zip") {
@@ -96,8 +96,10 @@ async function resolveMmdb() {
  const url =
    "https://github.com/Dreamacro/maxmind-geoip/releases/latest/download/Country.mmdb";

-  const resPath = path.join(cwd, "src-tauri", "resources", "Country.mmdb");
+  const resDir = path.join(cwd, "src-tauri", "resources");
+  const resPath = path.join(resDir, "Country.mmdb");
  if (await fs.pathExists(resPath)) return;
+  await fs.mkdirp(resDir);
  await downloadFile(url, resPath);
 }

@@ -118,5 +120,5 @@ async function downloadFile(url, path) {
 }

 /// main
-resolveSidecar();
-resolveMmdb();
+resolveSidecar().catch(console.error);
+resolveMmdb().catch(console.error);
--- a/scripts/release.mjs
+++ b/scripts/release.mjs
@@ -0,0 +1,68 @@
+import { createRequire } from "module";
+import { getOctokit, context } from "@actions/github";
+
+const require = createRequire(import.meta.url);
+
+/// generate update.json
+/// upload to update tag's release asset
+async function resolveRelease() {
+  if (process.env.GITHUB_TOKEN === undefined) {
+    throw new Error("GITHUB_TOKEN is required");
+  }
+
+  const packageJson = require("../package.json");
+
+  const { version } = packageJson;
+  const urlPrefix = "https://github.com/zzzgydi/clash-verge/releases/download";
+  const updateData = {
+    name: `v${version}`,
+    notes: `Version ${version} is available now!!!`,
+    pub_date: new Date().toISOString(),
+    platforms: {
+      win64: {
+        signature: "",
+        url: `${urlPrefix}/v${version}/clash-verge_${version}_x64.msi.zip`,
+      },
+      darwin: {
+        signature: "",
+        url: `${urlPrefix}/v${version}/clash-verge.app.tar.gz`,
+      },
+    },
+  };
+
+  console.log(`Generating Version "${version}" update.json`);
+
+  const github = getOctokit(process.env.GITHUB_TOKEN);
+
+  const { data: release } = await github.rest.repos.getReleaseByTag({
+    owner: context.repo.owner,
+    repo: context.repo.repo,
+    tag: "updater",
+  });
+  const { data: assets } = await github.rest.repos.listReleaseAssets({
+    owner: context.repo.owner,
+    repo: context.repo.repo,
+    release_id: release.id,
+  });
+
+  for (let asset of assets) {
+    if (asset.name === "update.json") {
+      await github.rest.repos.deleteReleaseAsset({
+        owner: context.repo.owner,
+        repo: context.repo.repo,
+        asset_id: asset.id,
+      });
+      break;
+    }
+  }
+
+  await github.rest.repos.uploadReleaseAsset({
+    owner: context.repo.owner,
+    repo: context.repo.repo,
+    release_id: release.id,
+    name: "update.json",
+    data: JSON.stringify(updateData, null, 2),
+  });
+}
+
+resolveRelease();
--- a/src-tauri/Cargo.lock
+++ b/src-tauri/Cargo.lock
--- a/src-tauri/Cargo.toml
+++ b/src-tauri/Cargo.toml
@@ -1,16 +1,16 @@
 [package]
-name = "app"
+name = "clash-verge"
 version = "0.1.0"
 description = "clash verge"
 authors = ["zzzgydi"]
 license = "GPL-3.0"
 repository = "https://github.com/zzzgydi/clash-verge.git"
-default-run = "app"
+default-run = "clash-verge"
 edition = "2021"
 build = "build.rs"

 [build-dependencies]
-tauri-build = { version = "1.0.0-beta.4" }
+tauri-build = { version = "1.0.0-rc.3", features = [] }

 [dependencies]
 dirs = "4.0.0"
@@ -18,9 +18,7 @@ chrono = "0.4.19"
 serde_json = "1.0"
 serde_yaml = "0.8"
 serde = { version = "1.0", features = ["derive"] }
-# tauri = { version = "1.0.0-beta.8", features = ["api-all", "system-tray"] }
-# tauri = { git = "https://github.com/tauri-apps/tauri", rev = "5e0d59ec", features = ["api-all", "system-tray"] }
-tauri = { git = "https://github.com/tauri-apps/tauri", branch = "next",  features = ["api-all", "system-tray", "updater"] }
+tauri = { version = "1.0.0-rc.3", features = ["shell-all", "system-tray", "updater", "window-all"] }
 tauri-plugin-shadows = { git = "https://github.com/tauri-apps/tauri-plugin-shadows", features = ["tauri-impl"] }
 tauri-plugin-vibrancy = { git = "https://github.com/tauri-apps/tauri-plugin-vibrancy", features = ["tauri-impl"] }

--- a/src-tauri/resources/config_tmp.yaml
+++ b/src-tauri/resources/config_tmp.yaml
@@ -1,7 +0,0 @@
-# Default Config For Clash Core
-
-mixed-port: 7890
-log-level: info
-allow-lan: false
-external-controller: 127.0.0.1:9090
-secret: ""
--- a/src-tauri/resources/profiles_tmp.yaml
+++ b/src-tauri/resources/profiles_tmp.yaml
@@ -1,3 +0,0 @@
-# Profiles Config for Clash Verge
-
-current: 0
--- a/src-tauri/resources/verge_tmp.yaml
+++ b/src-tauri/resources/verge_tmp.yaml
@@ -1,6 +0,0 @@
-# Defaulf Config For Clash Verge
-
-theme_mode: light
-enable_self_startup: false
-enable_system_proxy: false
-system_proxy_bypass: localhost;127.*;10.*;172.16.*;172.17.*;172.18.*;172.19.*;172.20.*;172.21.*;172.22.*;172.23.*;172.24.*;172.25.*;172.26.*;172.27.*;172.28.*;172.29.*;172.30.*;172.31.*;192.168.*;<local>
--- a/src-tauri/src/cmds.rs
+++ b/src-tauri/src/cmds.rs
@@ -1,22 +1,17 @@
 use crate::{
-  core::{ClashInfo, ProfileItem, ProfilesConfig, VergeConfig},
+  core::{ClashInfo, ProfileItem, Profiles, VergeConfig},
  states::{ClashState, ProfilesState, VergeState},
-  utils::{
-    config::{read_clash, save_clash},
-    dirs::app_home_dir,
-    fetch::fetch_profile,
-    sysopt::SysProxyConfig,
-  },
+  utils::{dirs::app_home_dir, fetch::fetch_profile, sysopt::SysProxyConfig},
 };
 use serde_yaml::Mapping;
 use std::process::Command;
-use tauri::State;
+use tauri::{api, State};

 /// get all profiles from `profiles.yaml`
 /// do not acquire the lock of ProfileLock
 #[tauri::command]
-pub fn get_profiles(profiles: State<'_, ProfilesState>) -> Result<ProfilesConfig, String> {
-  match profiles.0.lock() {
+pub fn get_profiles(profiles_state: State<'_, ProfilesState>) -> Result<Profiles, String> {
+  match profiles_state.0.lock() {
    Ok(profiles) => Ok(profiles.clone()),
    Err(_) => Err("failed to get profiles lock".into()),
  }
@@ -24,8 +19,8 @@ pub fn get_profiles(profiles: State<'_, ProfilesState>) -> Result<ProfilesConfig

 /// synchronize data irregularly
 #[tauri::command]
-pub fn sync_profiles(profiles: State<'_, ProfilesState>) -> Result<(), String> {
-  match profiles.0.lock() {
+pub fn sync_profiles(profiles_state: State<'_, ProfilesState>) -> Result<(), String> {
+  match profiles_state.0.lock() {
    Ok(mut profiles) => profiles.sync_file(),
    Err(_) => Err("failed to get profiles lock".into()),
  }
@@ -37,15 +32,25 @@ pub fn sync_profiles(profiles: State<'_, ProfilesState>) -> Result<(), String> {
 pub async fn import_profile(
  url: String,
  with_proxy: bool,
-  profiles: State<'_, ProfilesState>,
+  profiles_state: State<'_, ProfilesState>,
 ) -> Result<(), String> {
-  match fetch_profile(&url, with_proxy).await {
-    Some(result) => {
-      let mut profiles = profiles.0.lock().unwrap();
-      profiles.import_from_url(url, result)
-    }
-    None => Err(format!("failed to fetch profile from `{}`", url)),
-  }
+  let result = fetch_profile(&url, with_proxy).await?;
+  let mut profiles = profiles_state.0.lock().unwrap();
+  profiles.import_from_url(url, result)
+}
+
+/// new a profile
+/// append a temp profile item file to the `profiles` dir
+/// view the temp profile file by using vscode or other editor
+#[tauri::command]
+pub async fn new_profile(
+  name: String,
+  desc: String,
+  profiles_state: State<'_, ProfilesState>,
+) -> Result<(), String> {
+  let mut profiles = profiles_state.0.lock().unwrap();
+  profiles.append_item(name, desc)?;
+  Ok(())
 }

 /// Update the profile
@@ -53,11 +58,11 @@ pub async fn import_profile(
 pub async fn update_profile(
  index: usize,
  with_proxy: bool,
-  clash: State<'_, ClashState>,
-  profiles: State<'_, ProfilesState>,
+  clash_state: State<'_, ClashState>,
+  profiles_state: State<'_, ProfilesState>,
 ) -> Result<(), String> {
  // maybe we can get the url from the web app directly
-  let url = match profiles.0.lock() {
+  let url = match profiles_state.0.lock() {
    Ok(mut profile) => {
      let items = profile.items.take().unwrap_or(vec![]);
      if index >= items.len() {
@@ -73,23 +78,22 @@ pub async fn update_profile(
    Err(_) => return Err("failed to get profiles lock".into()),
  };

-  match fetch_profile(&url, with_proxy).await {
-    Some(result) => match profiles.0.lock() {
-      Ok(mut profiles) => {
-        profiles.update_item(index, result)?;
+  let result = fetch_profile(&url, with_proxy).await?;

-        // reactivate the profile
-        let current = profiles.current.clone().unwrap_or(0);
-        if current == index {
-          let clash = clash.0.lock().unwrap();
-          profiles.activate(clash.info.clone())
-        } else {
-          Ok(())
-        }
+  match profiles_state.0.lock() {
+    Ok(mut profiles) => {
+      profiles.update_item(index, result)?;
+
+      // reactivate the profile
+      let current = profiles.current.clone().unwrap_or(0);
+      if current == index {
+        let clash = clash_state.0.lock().unwrap();
+        profiles.activate(&clash)
+      } else {
+        Ok(())
      }
-      Err(_) => Err("failed to get profiles lock".into()),
-    },
-    None => Err(format!("failed to fetch profile from `{}`", url)),
+    }
+    Err(_) => Err("failed to get profiles lock".into()),
  }
 }

@@ -97,15 +101,15 @@ pub async fn update_profile(
 #[tauri::command]
 pub fn select_profile(
  index: usize,
-  clash: State<'_, ClashState>,
-  profiles: State<'_, ProfilesState>,
+  clash_state: State<'_, ClashState>,
+  profiles_state: State<'_, ProfilesState>,
 ) -> Result<(), String> {
-  let mut profiles = profiles.0.lock().unwrap();
+  let mut profiles = profiles_state.0.lock().unwrap();

  match profiles.put_current(index) {
    Ok(()) => {
-      let clash = clash.0.lock().unwrap();
-      profiles.activate(clash.info.clone())
+      let clash = clash_state.0.lock().unwrap();
+      profiles.activate(&clash)
    }
    Err(err) => Err(err),
  }
@@ -123,7 +127,7 @@ pub fn delete_profile(
    Ok(change) => match change {
      true => {
        let clash = clash_state.0.lock().unwrap();
-        profiles.activate(clash.info.clone())
+        profiles.activate(&clash)
      }
      false => Ok(()),
    },
@@ -136,9 +140,9 @@ pub fn delete_profile(
 pub fn patch_profile(
  index: usize,
  profile: ProfileItem,
-  profiles: State<'_, ProfilesState>,
+  profiles_state: State<'_, ProfilesState>,
 ) -> Result<(), String> {
-  match profiles.0.lock() {
+  match profiles_state.0.lock() {
    Ok(mut profiles) => profiles.patch_item(index, profile),
    Err(_) => Err("can not get profiles lock".into()),
  }
@@ -146,7 +150,7 @@ pub fn patch_profile(

 /// run vscode command to edit the profile
 #[tauri::command]
-pub fn edit_profile(index: usize, profiles_state: State<'_, ProfilesState>) -> Result<(), String> {
+pub fn view_profile(index: usize, profiles_state: State<'_, ProfilesState>) -> Result<(), String> {
  let mut profiles = profiles_state.0.lock().unwrap();
  let items = profiles.items.take().unwrap_or(vec![]);

@@ -160,15 +164,20 @@ pub fn edit_profile(index: usize, profiles_state: State<'_, ProfilesState>) -> R

  let path = app_home_dir().join("profiles").join(file);
  if !path.exists() {
-    return Err("failed to open the file".into());
+    return Err("the file not found".into());
  }

-  match which::which("code") {
-    Ok(code) => match Command::new(code).arg(path).status() {
+  // use vscode first
+  if let Ok(code) = which::which("code") {
+    return match Command::new(code).arg(path).spawn() {
      Ok(_) => Ok(()),
      Err(_) => Err("failed to open file by VScode".into()),
-    },
-    Err(_) => Err("please install VScode for edit".into()),
+    };
+  }
+
+  match open_command().arg(path).spawn() {
+    Ok(_) => Ok(()),
+    Err(_) => Err("failed to open file by `open`".into()),
  }
 }

@@ -179,18 +188,10 @@ pub fn restart_sidecar(
  profiles_state: State<'_, ProfilesState>,
 ) -> Result<(), String> {
  let mut clash = clash_state.0.lock().unwrap();
+  let mut profiles = profiles_state.0.lock().unwrap();

-  match clash.restart_sidecar() {
-    Ok(_) => {
-      let profiles = profiles_state.0.lock().unwrap();
-      match profiles.activate(clash.info.clone()) {
-        Ok(()) => Ok(()),
-        Err(err) => {
-          log::error!("{}", err);
-          Err(err)
-        }
-      }
-    }
+  match clash.restart_sidecar(&mut profiles) {
+    Ok(_) => Ok(()),
    Err(err) => {
      log::error!("{}", err);
      Err(err)
@@ -203,26 +204,25 @@ pub fn restart_sidecar(
 #[tauri::command]
 pub fn get_clash_info(clash_state: State<'_, ClashState>) -> Result<ClashInfo, String> {
  match clash_state.0.lock() {
-    Ok(arc) => Ok(arc.info.clone()),
+    Ok(clash) => Ok(clash.info.clone()),
    Err(_) => Err("failed to get clash lock".into()),
  }
 }

-/// todo: need refactor
 /// 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) -> Result<(), String> {
-  let mut config = read_clash();
-  for (key, value) in payload.iter() {
-    if config.contains_key(key) {
-      config[key] = value.clone();
-    } else {
-      config.insert(key.clone(), value.clone());
-    }
-  }
-  save_clash(&config)
+pub fn patch_clash_config(
+  payload: Mapping,
+  clash_state: State<'_, ClashState>,
+  verge_state: State<'_, VergeState>,
+  profiles_state: State<'_, ProfilesState>,
+) -> Result<(), String> {
+  let mut clash = clash_state.0.lock().unwrap();
+  let mut verge = verge_state.0.lock().unwrap();
+  let mut profiles = profiles_state.0.lock().unwrap();
+  clash.patch_config(payload, &mut verge, &mut profiles)
 }

 /// get the system proxy
@@ -247,19 +247,61 @@ pub fn get_cur_proxy(verge_state: State<'_, VergeState>) -> Result<Option<SysPro
 /// get the verge config
 #[tauri::command]
 pub fn get_verge_config(verge_state: State<'_, VergeState>) -> Result<VergeConfig, String> {
-  match verge_state.0.lock() {
-    Ok(arc) => Ok(arc.config.clone()),
-    Err(_) => Err("failed to get verge lock".into()),
+  let verge = verge_state.0.lock().unwrap();
+  let mut config = verge.config.clone();
+
+  if config.system_proxy_bypass.is_none() && verge.cur_sysproxy.is_some() {
+    config.system_proxy_bypass = Some(verge.cur_sysproxy.clone().unwrap().bypass)
  }
+
+  Ok(config)
 }

 /// patch the verge config
 /// this command only save the config and not responsible for other things
 #[tauri::command]
-pub async fn patch_verge_config(
+pub fn patch_verge_config(
  payload: VergeConfig,
  verge_state: State<'_, VergeState>,
 ) -> Result<(), String> {
  let mut verge = verge_state.0.lock().unwrap();
  verge.patch_config(payload)
 }
+
+/// kill all sidecars when update app
+#[tauri::command]
+pub fn kill_sidecars() {
+  api::process::kill_children();
+}
+
+/// open app config dir
+#[tauri::command]
+pub fn open_app_dir() -> Result<(), String> {
+  let app_dir = app_home_dir();
+
+  match open_command().arg(app_dir).spawn() {
+    Ok(_) => Ok(()),
+    Err(_) => Err("failed to open logs dir".into()),
+  }
+}
+
+/// open logs dir
+#[tauri::command]
+pub fn open_logs_dir() -> Result<(), String> {
+  let log_dir = app_home_dir().join("logs");
+
+  match open_command().arg(log_dir).spawn() {
+    Ok(_) => Ok(()),
+    Err(_) => Err("failed to open logs dir".into()),
+  }
+}
+
+/// get open/explorer command
+fn open_command() -> Command {
+  let open = if cfg!(target_os = "windows") {
+    "explorer"
+  } else {
+    "open"
+  };
+  Command::new(open)
+}
--- a/src-tauri/src/core/clash.rs
+++ b/src-tauri/src/core/clash.rs
@@ -1,3 +1,4 @@
+use super::{Profiles, Verge};
 use crate::utils::{config, dirs};
 use serde::{Deserialize, Serialize};
 use serde_yaml::{Mapping, Value};
@@ -20,6 +21,9 @@ pub struct ClashInfo {

 #[derive(Debug)]
 pub struct Clash {
+  /// maintain the clash config
+  pub config: Mapping,
+
  /// some info
  pub info: ClashInfo,

@@ -32,8 +36,19 @@ static CLASH_CONFIG: &str = "config.yaml";
 // todo: be able to change config field
 impl Clash {
  pub fn new() -> Clash {
-    let clash_config = config::read_yaml::<Mapping>(dirs::app_home_dir().join(CLASH_CONFIG));
+    let config = Clash::get_config();
+    let info = Clash::get_info(&config);

+    Clash {
+      config,
+      info,
+      sidecar: None,
+    }
+  }
+
+  /// parse the clash's config.yaml
+  /// get some information
+  fn get_info(clash_config: &Mapping) -> ClashInfo {
    let key_port_1 = Value::String("port".to_string());
    let key_port_2 = Value::String("mixed-port".to_string());
    let key_server = Value::String("external-controller".to_string());
@@ -76,14 +91,11 @@ impl Clash {
      _ => None,
    };

-    Clash {
-      info: ClashInfo {
-        status: "init".into(),
-        port,
-        server,
-        secret,
-      },
-      sidecar: None,
+    ClashInfo {
+      status: "init".into(),
+      port,
+      server,
+      secret,
    }
  }

@@ -126,9 +138,70 @@ impl Clash {
  }

  /// restart clash sidecar
-  pub fn restart_sidecar(&mut self) -> Result<(), String> {
+  /// should reactivate profile after restart
+  pub fn restart_sidecar(&mut self, profiles: &mut Profiles) -> Result<(), String> {
+    self.update_config();
    self.drop_sidecar()?;
-    self.run_sidecar()
+    self.run_sidecar()?;
+    profiles.activate(&self)
+  }
+
+  /// update the clash info
+  pub fn update_config(&mut self) {
+    self.config = Clash::get_config();
+    self.info = Clash::get_info(&self.config);
+  }
+
+  /// get clash config
+  fn get_config() -> Mapping {
+    config::read_yaml::<Mapping>(dirs::app_home_dir().join(CLASH_CONFIG))
+  }
+
+  /// save the clash config
+  fn save_config(&self) -> Result<(), String> {
+    config::save_yaml(
+      dirs::app_home_dir().join(CLASH_CONFIG),
+      &self.config,
+      Some("# Default Config For Clash Core\n\n"),
+    )
+  }
+
+  /// patch update the clash config
+  pub fn patch_config(
+    &mut self,
+    patch: Mapping,
+    verge: &mut Verge,
+    profiles: &mut Profiles,
+  ) -> Result<(), String> {
+    for (key, value) in patch.iter() {
+      let value = value.clone();
+      let key_str = key.as_str().clone().unwrap_or("");
+
+      // restart the clash
+      if key_str == "mixed-port" {
+        self.restart_sidecar(profiles)?;
+
+        let port = if value.is_number() {
+          match value.as_i64().clone() {
+            Some(num) => Some(format!("{num}")),
+            None => None,
+          }
+        } else {
+          match value.as_str().clone() {
+            Some(num) => Some(num.into()),
+            None => None,
+          }
+        };
+        verge.init_sysproxy(port);
+      }
+
+      if self.config.contains_key(key) {
+        self.config[key] = value;
+      } else {
+        self.config.insert(key.clone(), value);
+      }
+    }
+    self.save_config()
  }
 }

--- a/src-tauri/src/core/profiles.rs
+++ b/src-tauri/src/core/profiles.rs
@@ -1,18 +1,18 @@
-use crate::utils::{config, dirs};
+use super::{Clash, ClashInfo};
+use crate::utils::{config, dirs, tmpl};
 use reqwest::header::HeaderMap;
 use serde::{Deserialize, Serialize};
 use serde_yaml::{Mapping, Value};
 use std::collections::HashMap;
 use std::env::temp_dir;
-use std::fs::File;
+use std::fs::{remove_file, File};
 use std::io::Write;
+use std::path::PathBuf;
 use std::time::{SystemTime, UNIX_EPOCH};

-use super::ClashInfo;
-
 /// Define the `profiles.yaml` schema
 #[derive(Default, Debug, Clone, Deserialize, Serialize)]
-pub struct ProfilesConfig {
+pub struct Profiles {
  /// current profile's name
  pub current: Option<usize>,

@@ -24,6 +24,8 @@ pub struct ProfilesConfig {
 pub struct ProfileItem {
  /// profile name
  pub name: Option<String>,
+  /// profile description
+  pub desc: Option<String>,
  /// profile file
  pub file: Option<String>,
  /// current mode
@@ -58,16 +60,16 @@ pub struct ProfileResponse {
  pub name: String,
  pub file: String,
  pub data: String,
-  pub extra: ProfileExtra,
+  pub extra: Option<ProfileExtra>,
 }

 static PROFILE_YAML: &str = "profiles.yaml";
 static PROFILE_TEMP: &str = "clash-verge-runtime.yaml";

-impl ProfilesConfig {
+impl Profiles {
  /// read the config from the file
  pub fn read_file() -> Self {
-    config::read_yaml::<ProfilesConfig>(dirs::app_home_dir().join(PROFILE_YAML))
+    config::read_yaml::<Profiles>(dirs::app_home_dir().join(PROFILE_YAML))
  }

  /// save the config to the file
@@ -100,7 +102,7 @@ impl ProfilesConfig {
    File::create(path).unwrap().write(file_data).unwrap();

    // update `profiles.yaml`
-    let data = ProfilesConfig::read_file();
+    let data = Profiles::read_file();
    let mut items = data.items.unwrap_or(vec![]);

    let now = SystemTime::now()
@@ -110,11 +112,12 @@ impl ProfilesConfig {

    items.push(ProfileItem {
      name: Some(result.name),
+      desc: Some("imported url".into()),
      file: Some(result.file),
      mode: Some(format!("rule")),
      url: Some(url),
      selected: Some(vec![]),
-      extra: Some(result.extra),
+      extra: result.extra,
      updated: Some(now as usize),
    });

@@ -139,6 +142,40 @@ impl ProfilesConfig {
    self.save_file()
  }

+  /// append new item
+  /// return the new item's index
+  pub fn append_item(&mut self, name: String, desc: String) -> Result<(usize, PathBuf), String> {
+    let mut items = self.items.take().unwrap_or(vec![]);
+
+    // create a new profile file
+    let now = SystemTime::now()
+      .duration_since(UNIX_EPOCH)
+      .unwrap()
+      .as_secs();
+    let file = format!("{}.yaml", now);
+    let path = dirs::app_home_dir().join("profiles").join(&file);
+
+    match File::create(&path).unwrap().write(tmpl::ITEM_CONFIG) {
+      Ok(_) => {
+        items.push(ProfileItem {
+          name: Some(name),
+          desc: Some(desc),
+          file: Some(file),
+          mode: None,
+          url: None,
+          selected: Some(vec![]),
+          extra: None,
+          updated: Some(now as usize),
+        });
+
+        let index = items.len();
+        self.items = Some(items);
+        Ok((index, path))
+      }
+      Err(_) => Err("failed to create file".into()),
+    }
+  }
+
  /// update the target profile
  /// and save to config file
  /// only support the url item
@@ -157,7 +194,7 @@ impl ProfilesConfig {
    File::create(file_path).unwrap().write(file_data).unwrap();

    items[index].name = Some(result.name);
-    items[index].extra = Some(result.extra);
+    items[index].extra = result.extra;
    items[index].updated = Some(now);

    self.items = Some(items);
@@ -203,7 +240,18 @@ impl ProfilesConfig {
      return Err("index out of bound".into());
    }

-    items.remove(index);
+    let mut rm_item = items.remove(index);
+
+    // delete the file
+    if let Some(file) = rm_item.file.take() {
+      let file_path = dirs::app_home_dir().join("profiles").join(file);
+
+      if file_path.exists() {
+        if let Err(err) = remove_file(file_path) {
+          log::error!("{err}");
+        }
+      }
+    }

    let mut should_change = false;

@@ -224,7 +272,7 @@ impl ProfilesConfig {
  }

  /// activate current profile
-  pub fn activate(&self, clash_config: ClashInfo) -> Result<(), String> {
+  pub fn activate(&self, clash: &Clash) -> Result<(), String> {
    let current = self.current.unwrap_or(0);
    match self.items.clone() {
      Some(items) => {
@@ -233,11 +281,13 @@ impl ProfilesConfig {
        }

        let profile = items[current].clone();
+        let clash_config = clash.config.clone();
+        let clash_info = clash.info.clone();
        tauri::async_runtime::spawn(async move {
          let mut count = 5; // retry times
          let mut err = String::from("");
          while count > 0 {
-            match activate_profile(&profile, &clash_config).await {
+            match activate_profile(&profile, &clash_config, &clash_info).await {
              Ok(_) => return,
              Err(e) => err = e,
            }
@@ -254,7 +304,11 @@ impl ProfilesConfig {
 }

 /// put the profile to clash
-pub async fn activate_profile(profile_item: &ProfileItem, info: &ClashInfo) -> Result<(), String> {
+pub async fn activate_profile(
+  profile_item: &ProfileItem,
+  clash_config: &Mapping,
+  clash_info: &ClashInfo,
+) -> Result<(), String> {
  // temp profile's path
  let temp_path = temp_dir().join(PROFILE_TEMP);

@@ -267,25 +321,47 @@ pub async fn activate_profile(profile_item: &ProfileItem, info: &ClashInfo) -> R

    let file_path = dirs::app_home_dir().join("profiles").join(file_name);
    if !file_path.exists() {
-      return Err(format!("profile `{:?}` not exists", file_path));
+      return Err(format!(
+        "profile `{}` not exists",
+        file_path.as_os_str().to_str().unwrap()
+      ));
    }

+    // begin to generate the new profile config
+    let def_config = config::read_yaml::<Mapping>(file_path.clone());
+    let mut new_config = Mapping::new();
+
    // Only the following fields are allowed:
    // proxies/proxy-providers/proxy-groups/rule-providers/rules
-    let config = config::read_yaml::<Mapping>(file_path.clone());
-    let mut new_config = Mapping::new();
-    vec![
+    let valid_keys = vec![
      "proxies",
      "proxy-providers",
      "proxy-groups",
      "rule-providers",
      "rules",
-    ]
-    .iter()
-    .map(|item| Value::String(item.to_string()))
-    .for_each(|key| {
-      if config.contains_key(&key) {
-        let value = config[&key].clone();
+    ];
+    valid_keys.iter().for_each(|key| {
+      let key = Value::String(key.to_string());
+      if def_config.contains_key(&key) {
+        let value = def_config[&key].clone();
+        new_config.insert(key, value);
+      }
+    });
+
+    // add some of the clash `config.yaml` config to it
+    let valid_keys = vec![
+      "mixed-port",
+      "log-level",
+      "allow-lan",
+      "external-controller",
+      "secret",
+      "mode",
+      "ipv6",
+    ];
+    valid_keys.iter().for_each(|key| {
+      let key = Value::String(key.to_string());
+      if clash_config.contains_key(&key) {
+        let value = clash_config[&key].clone();
        new_config.insert(key, value);
      }
    });
@@ -297,12 +373,12 @@ pub async fn activate_profile(profile_item: &ProfileItem, info: &ClashInfo) -> R
    )?
  };

-  let server = format!("http://{}/configs", info.server.clone().unwrap());
+  let server = format!("http://{}/configs", clash_info.server.clone().unwrap());

  let mut headers = HeaderMap::new();
  headers.insert("Content-Type", "application/json".parse().unwrap());

-  if let Some(secret) = info.secret.clone() {
+  if let Some(secret) = clash_info.secret.clone() {
    headers.insert(
      "Authorization",
      format!("Bearer {}", secret).parse().unwrap(),
--- a/src-tauri/src/core/verge.rs
+++ b/src-tauri/src/core/verge.rs
@@ -1,7 +1,11 @@
-use crate::utils::{config, dirs, sysopt::SysProxyConfig};
+use crate::{
+  core::Clash,
+  utils::{config, dirs, sysopt::SysProxyConfig},
+};
 use auto_launch::{AutoLaunch, AutoLaunchBuilder};
 use serde::{Deserialize, Serialize};
-use tauri::api::path::resource_dir;
+use std::sync::Arc;
+use tauri::{api::path::resource_dir, async_runtime::Mutex};

 /// ### `verge.yaml` schema
 #[derive(Default, Debug, Clone, Deserialize, Serialize)]
@@ -13,14 +17,23 @@ pub struct VergeConfig {
  /// maybe be able to set the alpha
  pub theme_blur: Option<bool>,

+  /// enable traffic graph default is true
+  pub traffic_graph: Option<bool>,
+
  /// can the app auto startup
  pub enable_auto_launch: 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>,
 }

 static VERGE_CONFIG: &str = "verge.yaml";
@@ -50,6 +63,9 @@ pub struct Verge {
  pub cur_sysproxy: Option<SysProxyConfig>,

  pub auto_launch: Option<AutoLaunch>,
+
+  /// record whether the guard async is running or not
+  guard_state: Arc<Mutex<bool>>,
 }

 impl Default for Verge {
@@ -65,6 +81,7 @@ impl Verge {
      old_sysproxy: None,
      cur_sysproxy: None,
      auto_launch: None,
+      guard_state: Arc::new(Mutex::new(false)),
    }
  }

@@ -89,6 +106,9 @@ impl Verge {

      self.cur_sysproxy = Some(sysproxy);
    }
+
+    // launchs the system proxy guard
+    Verge::guard_proxy(self.guard_state.clone());
  }

  /// reset the sysproxy
@@ -105,7 +125,9 @@ impl Verge {
  pub fn init_launch(&mut self, package_info: &tauri::PackageInfo) {
    let app_name = "clash-verge";
    let app_path = get_app_path(app_name);
-    let app_path = resource_dir(package_info).unwrap().join(app_path);
+    let app_path = resource_dir(package_info, &tauri::Env::default())
+      .unwrap()
+      .join(app_path);
    let app_path = app_path.as_os_str().to_str().unwrap();

    let auto = AutoLaunchBuilder::new()
@@ -149,15 +171,17 @@ impl Verge {

    let auto_launch = self.auto_launch.clone().unwrap();

-    let result = if enable {
-      auto_launch.enable()
-    } else {
-      auto_launch.disable()
+    let result = match enable {
+      true => auto_launch.enable(),
+      false => auto_launch.disable(),
    };

    match result {
      Ok(_) => Ok(()),
-      Err(_) => Err("failed to set system startup info".into()),
+      Err(err) => {
+        log::error!("{err}");
+        Err("failed to set system startup info".into())
+      }
    }
  }

@@ -172,6 +196,9 @@ impl Verge {
    if patch.theme_blur.is_some() {
      self.config.theme_blur = patch.theme_blur;
    }
+    if patch.traffic_graph.is_some() {
+      self.config.traffic_graph = patch.traffic_graph;
+    }

    // should update system startup
    if patch.enable_auto_launch.is_some() {
@@ -183,9 +210,12 @@ impl Verge {
    // should update system proxy
    if patch.enable_system_proxy.is_some() {
      let enable = patch.enable_system_proxy.unwrap();
+
      if let Some(mut sysproxy) = self.cur_sysproxy.take() {
        sysproxy.enable = enable;
        if sysproxy.set_sys().is_err() {
+          self.cur_sysproxy = Some(sysproxy);
+
          log::error!("failed to set system proxy");
          return Err("failed to set system proxy".into());
        }
@@ -194,22 +224,113 @@ impl Verge {
      self.config.enable_system_proxy = Some(enable);
    }

-    // todo
    // should update system proxy too
    if patch.system_proxy_bypass.is_some() {
-      self.config.system_proxy_bypass = patch.system_proxy_bypass;
+      let bypass = patch.system_proxy_bypass.unwrap();
+
+      if let Some(mut sysproxy) = self.cur_sysproxy.take() {
+        if sysproxy.enable {
+          sysproxy.bypass = bypass.clone();
+
+          if sysproxy.set_sys().is_err() {
+            self.cur_sysproxy = Some(sysproxy);
+
+            log::error!("failed to set system proxy");
+            return Err("failed to set system proxy".into());
+          }
+        }
+
+        self.cur_sysproxy = Some(sysproxy);
+      }
+
+      self.config.system_proxy_bypass = Some(bypass);
+    }
+
+    // proxy guard
+    // only change it
+    if patch.enable_proxy_guard.is_some() {
+      self.config.enable_proxy_guard = patch.enable_proxy_guard;
+    }
+    if patch.proxy_guard_duration.is_some() {
+      self.config.proxy_guard_duration = patch.proxy_guard_duration;
+    }
+
+    // relaunch the guard
+    if patch.enable_system_proxy.is_some() || patch.enable_proxy_guard.is_some() {
+      Verge::guard_proxy(self.guard_state.clone());
    }

    self.config.save_file()
  }
 }

+impl Verge {
+  /// launch a system proxy guard
+  /// read config from file directly
+  pub fn guard_proxy(guard_state: Arc<Mutex<bool>>) {
+    use tokio::time::{sleep, Duration};
+
+    tauri::async_runtime::spawn(async move {
+      // if it is running, exit
+      let mut state = guard_state.lock().await;
+      if *state {
+        return;
+      }
+      *state = true;
+      std::mem::drop(state);
+
+      // default duration is 10s
+      let mut wait_secs = 10u64;
+
+      loop {
+        sleep(Duration::from_secs(wait_secs)).await;
+
+        log::debug!("[Guard]: heartbeat detection");
+
+        let verge = Verge::new();
+
+        let enable_proxy = verge.config.enable_system_proxy.unwrap_or(false);
+        let enable_guard = verge.config.enable_proxy_guard.unwrap_or(false);
+        let guard_duration = verge.config.proxy_guard_duration.unwrap_or(10);
+
+        // update duration
+        wait_secs = guard_duration;
+
+        // stop loop
+        if !enable_guard || !enable_proxy {
+          break;
+        }
+
+        log::info!("[Guard]: try to guard proxy");
+
+        let clash = Clash::new();
+
+        match &clash.info.port {
+          Some(port) => {
+            let bypass = verge.config.system_proxy_bypass.clone();
+            let sysproxy = SysProxyConfig::new(true, port.clone(), bypass);
+
+            if let Err(err) = sysproxy.set_sys() {
+              log::error!("[Guard]: {err}");
+              log::error!("[Guard]: fail to set system proxy");
+            }
+          }
+          None => log::error!("[Guard]: fail to parse clash port"),
+        }
+      }
+
+      let mut state = guard_state.lock().await;
+      *state = false;
+    });
+  }
+}
+
 // Get the target app_path
 fn get_app_path(app_name: &str) -> String {
  #[cfg(target_os = "linux")]
  let ext = "";
  #[cfg(target_os = "macos")]
-  let ext = ".app";
+  let ext = "";
  #[cfg(target_os = "windows")]
  let ext = ".exe";
  String::from(app_name) + ext
--- a/src-tauri/src/main.rs
+++ b/src-tauri/src/main.rs
@@ -41,30 +41,31 @@ fn main() -> std::io::Result<()> {
        }
        "restart_clash" => {
          let clash_state = app_handle.state::<states::ClashState>();
+          let profiles_state = app_handle.state::<states::ProfilesState>();
          let mut clash = clash_state.0.lock().unwrap();
-          match clash.restart_sidecar() {
+          let mut profiles = profiles_state.0.lock().unwrap();
+          match clash.restart_sidecar(&mut profiles) {
            Ok(_) => {
-              let profiles = app_handle.state::<states::ProfilesState>();
-              let profiles = profiles.0.lock().unwrap();
-              if let Err(err) = profiles.activate(clash.info.clone()) {
-                log::error!("{}", err);
-              }
+              let window = app_handle.get_window("main").unwrap();
+              window.emit("restart_clash", "yes").unwrap();
            }
            Err(err) => log::error!("{}", err),
          }
        }
        "quit" => {
-          api::process::kill_children();
          resolve::resolve_reset(app_handle);
-          app_handle.exit(0);
+          api::process::kill_children();
+          std::process::exit(0);
        }
        _ => {}
      },
      SystemTrayEvent::LeftClick { .. } => {
-        let window = app_handle.get_window("main").unwrap();
-        window.unminimize().unwrap();
-        window.show().unwrap();
-        window.set_focus().unwrap();
+        if cfg![target_os = "windows"] {
+          let window = app_handle.get_window("main").unwrap();
+          window.unminimize().unwrap();
+          window.show().unwrap();
+          window.set_focus().unwrap();
+        }
      }
      _ => {}
    })
@@ -73,6 +74,9 @@ fn main() -> std::io::Result<()> {
      cmds::restart_sidecar,
      cmds::get_sys_proxy,
      cmds::get_cur_proxy,
+      cmds::kill_sidecars,
+      cmds::open_app_dir,
+      cmds::open_logs_dir,
      // clash
      cmds::get_clash_info,
      cmds::patch_clash_config,
@@ -80,7 +84,8 @@ fn main() -> std::io::Result<()> {
      cmds::get_verge_config,
      cmds::patch_verge_config,
      // profile
-      cmds::edit_profile,
+      cmds::new_profile,
+      cmds::view_profile,
      cmds::patch_profile,
      cmds::import_profile,
      cmds::update_profile,
@@ -92,12 +97,12 @@ fn main() -> std::io::Result<()> {
    .build(tauri::generate_context!())
    .expect("error while running tauri application")
    .run(|app_handle, e| match e {
-      tauri::Event::CloseRequested { label, api, .. } => {
+      tauri::RunEvent::CloseRequested { label, api, .. } => {
        let app_handle = app_handle.clone();
        api.prevent_close();
        app_handle.get_window(&label).unwrap().hide().unwrap();
      }
-      tauri::Event::ExitRequested { .. } => {
+      tauri::RunEvent::ExitRequested { .. } => {
        resolve::resolve_reset(app_handle);
        api::process::kill_children();
      }
--- a/src-tauri/src/states.rs
+++ b/src-tauri/src/states.rs
@@ -1,8 +1,8 @@
-use crate::core::{Clash, ProfilesConfig, Verge};
+use crate::core::{Clash, Profiles, Verge};
 use std::sync::{Arc, Mutex};

 #[derive(Default)]
-pub struct ProfilesState(pub Arc<Mutex<ProfilesConfig>>);
+pub struct ProfilesState(pub Arc<Mutex<Profiles>>);

 #[derive(Default)]
 pub struct ClashState(pub Arc<Mutex<Clash>>);
--- a/src-tauri/src/utils/config.rs
+++ b/src-tauri/src/utils/config.rs
@@ -1,6 +1,4 @@
-use crate::utils::dirs;
 use serde::{de::DeserializeOwned, Serialize};
-use serde_yaml::Mapping;
 use std::{fs, path::PathBuf};

 /// read data from yaml as struct T
@@ -32,17 +30,3 @@ pub fn save_yaml<T: Serialize>(
    Err(_) => Err("can not convert the data to yaml".into()),
  }
 }
-
-/// Get Clash Core Config `config.yaml`
-pub fn read_clash() -> Mapping {
-  read_yaml::<Mapping>(dirs::app_home_dir().join("config.yaml"))
-}
-
-/// Save the clash core Config `config.yaml`
-pub fn save_clash(config: &Mapping) -> Result<(), String> {
-  save_yaml(
-    dirs::app_home_dir().join("config.yaml"),
-    config,
-    Some("# Default Config For Clash Core\n\n"),
-  )
-}
--- a/src-tauri/src/utils/dirs.rs
+++ b/src-tauri/src/utils/dirs.rs
@@ -1,7 +1,7 @@
 use std::path::{Path, PathBuf};
 use tauri::{
  api::path::{home_dir, resource_dir},
-  PackageInfo,
+  Env, PackageInfo,
 };

 /// get the verge app home dir
@@ -14,5 +14,7 @@ pub fn app_home_dir() -> PathBuf {

 /// get the resources dir
 pub fn app_resources_dir(package_info: &PackageInfo) -> PathBuf {
-  resource_dir(package_info).unwrap().join("resources")
+  resource_dir(package_info, &Env::default())
+    .unwrap()
+    .join("resources")
 }
--- a/src-tauri/src/utils/fetch.rs
+++ b/src-tauri/src/utils/fetch.rs
@@ -22,66 +22,63 @@ fn parse_string<T: FromStr>(target: &str, key: &str) -> Option<T> {
  }
 }

-/// fetch and parse the profile
-pub async fn fetch_profile(url: &str, with_proxy: bool) -> Option<ProfileResponse> {
+/// fetch and parse the profile url
+/// maybe it contains some Subscription infomations, maybe not
+pub async fn fetch_profile(url: &str, with_proxy: bool) -> Result<ProfileResponse, String> {
  let builder = reqwest::ClientBuilder::new();
  let client = match with_proxy {
    true => builder.build(),
    false => builder.no_proxy().build(),
  };
-  let resp = match client {
-    Ok(client) => match client.get(url).send().await {
-      Ok(res) => res,
-      Err(_) => return None,
-    },
-    Err(_) => return None,
+
+  let resp = match client.unwrap().get(url).send().await {
+    Ok(res) => res,
+    Err(_) => return Err("failed to create https client".into()),
  };

  let header = resp.headers();

  // parse the Subscription Userinfo
-  let extra = {
-    let sub_info = match header.get("Subscription-Userinfo") {
-      Some(value) => value.to_str().unwrap_or(""),
-      None => "",
-    };
+  let extra = match header.get("Subscription-Userinfo") {
+    Some(value) => {
+      let sub_info = value.to_str().unwrap_or("");

-    ProfileExtra {
-      upload: parse_string(sub_info, "upload=").unwrap_or(0),
-      download: parse_string(sub_info, "download=").unwrap_or(0),
-      total: parse_string(sub_info, "total=").unwrap_or(0),
-      expire: parse_string(sub_info, "expire=").unwrap_or(0),
+      Some(ProfileExtra {
+        upload: parse_string(sub_info, "upload=").unwrap_or(0),
+        download: parse_string(sub_info, "download=").unwrap_or(0),
+        total: parse_string(sub_info, "total=").unwrap_or(0),
+        expire: parse_string(sub_info, "expire=").unwrap_or(0),
+      })
    }
+    None => None,
  };

-  // parse the `name` and `file`
-  let (name, file) = {
+  let file = {
    let now = SystemTime::now()
      .duration_since(UNIX_EPOCH)
      .unwrap()
      .as_secs();
-    let file = format!("{}.yaml", now);
-    let name = header.get("Content-Disposition").unwrap().to_str().unwrap();
-    let name = parse_string::<String>(name, "filename=");
+    format!("{}.yaml", now)
+  };

-    match name {
-      Some(f) => (f, file),
-      None => (file.clone(), file),
+  let name = match header.get("Content-Disposition") {
+    Some(name) => {
+      let name = name.to_str().unwrap();
+      parse_string::<String>(name, "filename=").unwrap_or(file.clone())
    }
+    None => file.clone(),
  };

  // get the data
-  let data = match resp.text_with_charset("utf-8").await {
-    Ok(d) => d,
-    Err(_) => return None,
-  };
-
-  Some(ProfileResponse {
-    file,
-    name,
-    data,
-    extra,
-  })
+  match resp.text_with_charset("utf-8").await {
+    Ok(data) => Ok(ProfileResponse {
+      file,
+      name,
+      data,
+      extra,
+    }),
+    Err(_) => Err("failed to parse the response data".into()),
+  }
 }

 #[test]
--- a/src-tauri/src/utils/init.rs
+++ b/src-tauri/src/utils/init.rs
@@ -1,6 +1,6 @@
 extern crate serde_yaml;

-use crate::utils::dirs;
+use crate::utils::{dirs, tmpl};
 use chrono::Local;
 use log::LevelFilter;
 use log4rs::append::console::ConsoleAppender;
@@ -41,44 +41,22 @@ fn init_log(log_dir: &PathBuf) {
 }

 /// Initialize all the files from resources
-fn init_config_file(app_dir: &PathBuf, res_dir: &PathBuf) {
+fn init_config(app_dir: &PathBuf) -> std::io::Result<()> {
  // target path
  let clash_path = app_dir.join("config.yaml");
  let verge_path = app_dir.join("verge.yaml");
  let profile_path = app_dir.join("profiles.yaml");
-  let mmdb_path = app_dir.join("Country.mmdb");
-
-  // template path
-  let clash_tmpl = res_dir.join("config_tmp.yaml");
-  let verge_tmpl = res_dir.join("verge_tmp.yaml");
-  let profiles_tmpl = res_dir.join("profiles_tmp.yaml");
-  let mmdb_tmpl = res_dir.join("Country.mmdb");

  if !clash_path.exists() {
-    if clash_tmpl.exists() {
-      fs::copy(clash_tmpl, clash_path).unwrap();
-    } else {
-      // make sure that the config.yaml not null
-      let content = b"\
-        mixed-port: 7890\n\
-        log-level: info\n\
-        allow-lan: false\n\
-        external-controller: 127.0.0.1:9090\n\
-        secret: \"\"\n";
-      File::create(clash_path).unwrap().write(content).unwrap();
-    }
+    File::create(clash_path)?.write(tmpl::CLASH_CONFIG)?;
  }
-
-  // only copy it
-  if !verge_path.exists() && verge_tmpl.exists() {
-    fs::copy(verge_tmpl, verge_path).unwrap();
+  if !verge_path.exists() {
+    File::create(verge_path)?.write(tmpl::VERGE_CONFIG)?;
  }
-  if !profile_path.exists() && profiles_tmpl.exists() {
-    fs::copy(profiles_tmpl, profile_path).unwrap();
-  }
-  if !mmdb_path.exists() && mmdb_tmpl.exists() {
-    fs::copy(mmdb_tmpl, mmdb_path).unwrap();
+  if !profile_path.exists() {
+    File::create(profile_path)?.write(tmpl::PROFILES_CONFIG)?;
  }
+  Ok(())
 }

 /// initialize app
@@ -101,5 +79,14 @@ pub fn init_app(package_info: &PackageInfo) {
  }

  init_log(&log_dir);
-  init_config_file(&app_dir, &res_dir);
+  if let Err(err) = init_config(&app_dir) {
+    log::error!("{err}");
+  }
+
+  // copy the resource file
+  let mmdb_path = app_dir.join("Country.mmdb");
+  let mmdb_tmpl = res_dir.join("Country.mmdb");
+  if !mmdb_path.exists() && mmdb_tmpl.exists() {
+    fs::copy(mmdb_tmpl, mmdb_path).unwrap();
+  }
 }
--- a/src-tauri/src/utils/mod.rs
+++ b/src-tauri/src/utils/mod.rs
@@ -5,3 +5,4 @@ pub mod init;
 pub mod resolve;
 pub mod server;
 pub mod sysopt;
+pub mod tmpl;
--- a/src-tauri/src/utils/resolve.rs
+++ b/src-tauri/src/utils/resolve.rs
@@ -1,23 +1,10 @@
 use super::{init, server};
-use crate::{core::ProfilesConfig, states};
+use crate::{core::Profiles, states};
 use tauri::{App, AppHandle, Manager};
-use tauri_plugin_shadows::Shadows;

 /// handle something when start app
 pub fn resolve_setup(app: &App) {
-  // set shadow when window decorations
-  let window = app.get_window("main").unwrap();
-  window.set_shadow(true);
-
-  // enable system blur
-  use tauri_plugin_vibrancy::Vibrancy;
-  #[cfg(target_os = "windows")]
-  window.apply_blur();
-  #[cfg(target_os = "macos")]
-  {
-    use tauri_plugin_vibrancy::MacOSVibrancy;
-    window.apply_vibrancy(MacOSVibrancy::AppearanceBased);
-  }
+  resolve_window(app);

  // setup a simple http server for singleton
  server::embed_server(&app.handle());
@@ -38,8 +25,8 @@ pub fn resolve_setup(app: &App) {
    log::error!("{}", err);
  }

-  *profiles = ProfilesConfig::read_file();
-  if let Err(err) = profiles.activate(clash.info.clone()) {
+  *profiles = Profiles::read_file();
+  if let Err(err) = profiles.activate(&clash) {
    log::error!("{}", err);
  }

@@ -57,3 +44,34 @@ pub fn resolve_reset(app_handle: &AppHandle) {

  verge.reset_sysproxy();
 }
+
+/// customize the window theme
+fn resolve_window(app: &App) {
+  let window = app.get_window("main").unwrap();
+
+  #[cfg(target_os = "windows")]
+  {
+    use tauri_plugin_shadows::Shadows;
+    use tauri_plugin_vibrancy::Vibrancy;
+
+    window.set_decorations(false).unwrap();
+    window.set_shadow(true);
+    window.apply_blur();
+  }
+
+  #[cfg(target_os = "macos")]
+  {
+    use tauri::LogicalSize;
+    use tauri::Size::Logical;
+    window.set_decorations(true).unwrap();
+    window
+      .set_size(Logical(LogicalSize {
+        width: 800.0,
+        height: 610.0,
+      }))
+      .unwrap();
+    // use tauri_plugin_vibrancy::MacOSVibrancy;
+    // #[allow(deprecated)]
+    // window.apply_vibrancy(MacOSVibrancy::AppearanceBased);
+  }
+}
--- a/src-tauri/src/utils/tmpl.rs
+++ b/src-tauri/src/utils/tmpl.rs
@@ -0,0 +1,42 @@
+///! Some config file template
+
+/// template for clash core `config.yaml`
+pub const CLASH_CONFIG: &[u8] = br#"# Default Config For Clash Core
+
+mixed-port: 7890
+log-level: info
+allow-lan: false
+external-controller: 127.0.0.1:9090
+mode: rule
+secret: ""
+"#;
+
+/// template for `profiles.yaml`
+pub const PROFILES_CONFIG: &[u8] = b"# Profiles Config for Clash Verge
+
+current: 0
+items: ~
+";
+
+/// template for `verge.yaml`
+pub const VERGE_CONFIG: &[u8] = b"# Defaulf Config For Clash Verge
+
+theme_mode: light
+theme_blur: false
+traffic_graph: true
+enable_self_startup: false
+enable_system_proxy: false
+enable_proxy_guard: false
+proxy_guard_duration: 10
+system_proxy_bypass: localhost;127.*;10.*;192.168.*;<local>
+";
+
+/// template for new a profile item
+pub const ITEM_CONFIG: &[u8] = b"# Profile Template for clash verge\n\n
+# proxies defination (optional, the same as clash)
+proxies:\n
+# proxy-groups (optional, the same as clash)
+proxy-groups:\n
+# rules (optional, the same as clash)
+rules:\n\n
+";
--- a/src-tauri/tauri.conf.json
+++ b/src-tauri/tauri.conf.json
@@ -1,7 +1,7 @@
 {
  "package": {
    "productName": "clash-verge",
-    "version": "0.0.11"
+    "version": "0.0.16"
  },
  "build": {
    "distDir": "../dist",
@@ -54,10 +54,16 @@
      "endpoints": [
        "https://github.com/zzzgydi/clash-verge/releases/download/updater/update.json"
      ],
-      "dialog": false
+      "dialog": false,
+      "pubkey": "dW50cnVzdGVkIGNvbW1lbnQ6IG1pbmlzaWduIHB1YmxpYyBrZXk6IDExNUFBNTBBN0FDNEFBRTUKUldUbHFzUjZDcVZhRVRJM25NS3NkSFlFVElxUkNZMzZ6bHUwRVJjb2F3alJXVzRaeDdSaTA2YWYK"
    },
    "allowlist": {
-      "all": true
+      "shell": {
+        "all": true
+      },
+      "window": {
+        "all": true
+      }
    },
    "windows": [
      {
--- a/src/assets/styles/index.scss
+++ b/src/assets/styles/index.scss
@@ -4,6 +4,7 @@ body {
    "Ubuntu", "Cantarell", "Fira Sans", "Droid Sans", "Helvetica Neue",
    sans-serif;
  -webkit-font-smoothing: antialiased;
+  user-select: none;
 }

 :root {
--- a/src/assets/styles/layout.scss
+++ b/src/assets/styles/layout.scss
@@ -20,8 +20,8 @@
      position: relative;
      flex: 0 1 180px;
      width: 100%;
-      max-width: 180px;
-      max-height: 180px;
+      max-width: 168px;
+      max-height: 168px;
      margin: 0 auto;
      padding: 0 8px;
      text-align: center;
@@ -72,10 +72,16 @@

    .the-content {
      position: absolute;
-      left: 0;
-      right: 0;
      top: 30px;
+      left: 0;
+      right: 2px;
      bottom: 10px;
    }
  }
 }
+
+.macos.layout {
+  .layout__right .the-content {
+    top: 0;
+  }
+}
--- a/src/assets/styles/page.scss
+++ b/src/assets/styles/page.scss
@@ -9,6 +9,8 @@
    width: 90%;
    max-width: 850px;
    margin: 0 auto;
+    padding-right: 4px;
+    box-sizing: border-box;
    display: flex;
    align-items: center;
    justify-content: space-between;
--- a/src/components/base/base-notice.tsx
+++ b/src/components/base/base-notice.tsx
--- a/src/components/base/base-page.tsx
+++ b/src/components/base/base-page.tsx
@@ -12,15 +12,15 @@ const BasePage: React.FC<Props> = (props) => {

  return (
    <div className="base-page" data-windrag>
-      <header data-windrag>
-        <Typography variant="h4" component="h1">
+      <header data-windrag style={{ userSelect: "none" }}>
+        <Typography variant="h4" component="h1" data-windrag>
          {title}
        </Typography>

        {header}
      </header>

-      <section data-windrag>
+      <section>
        <div className="base-content" style={contentStyle} data-windrag>
          {children}
        </div>
--- a/src/components/connection/connection-item.tsx
+++ b/src/components/connection/connection-item.tsx
@@ -1,4 +1,4 @@
-import { ApiType } from "../services/types";
+import { ApiType } from "../../services/types";

 interface Props {
  value: ApiType.ConnectionsItem;
--- a/src/components/layout/layout-control.tsx
+++ b/src/components/layout/layout-control.tsx
--- a/src/components/layout/layout-item.tsx
+++ b/src/components/layout/layout-item.tsx
--- a/src/components/layout/layout-traffic.tsx
+++ b/src/components/layout/layout-traffic.tsx
@@ -1,12 +1,23 @@
+import useSWR from "swr";
 import { useEffect, useState } from "react";
+import { useRecoilValue } from "recoil";
 import { Box, Typography } from "@mui/material";
 import { ArrowDownward, ArrowUpward } from "@mui/icons-material";
-import { getInfomation } from "../services/api";
-import { ApiType } from "../services/types";
-import parseTraffic from "../utils/parse-traffic";
+import { ApiType } from "../../services/types";
+import { getInfomation } from "../../services/api";
+import { getVergeConfig } from "../../services/cmds";
+import { atomClashPort } from "../../states/setting";
+import parseTraffic from "../../utils/parse-traffic";
+import useTrafficGraph from "./use-traffic-graph";

-const Traffic = () => {
+const LayoutTraffic = () => {
+  const portValue = useRecoilValue(atomClashPort);
  const [traffic, setTraffic] = useState({ up: 0, down: 0 });
+  const { canvasRef, appendData, toggleStyle } = useTrafficGraph();
+
+  // whether hide traffic graph
+  const { data } = useSWR("getVergeConfig", getVergeConfig);
+  const trafficGraph = data?.traffic_graph ?? true;

  useEffect(() => {
    let ws: WebSocket | null = null;
@@ -16,12 +27,14 @@ const Traffic = () => {
      ws = new WebSocket(`ws://${server}/traffic?token=${secret}`);

      ws.addEventListener("message", (event) => {
-        setTraffic(JSON.parse(event.data) as ApiType.TrafficItem);
+        const data = JSON.parse(event.data) as ApiType.TrafficItem;
+        appendData(data);
+        setTraffic(data);
      });
    });

    return () => ws?.close();
-  }, []);
+  }, [portValue]);

  const [up, upUnit] = parseTraffic(traffic.up);
  const [down, downUnit] = parseTraffic(traffic.down);
@@ -41,7 +54,14 @@ const Traffic = () => {
  };

  return (
-    <Box width="110px">
+    <Box width="110px" position="relative" onClick={toggleStyle}>
+      {trafficGraph && (
+        <canvas
+          ref={canvasRef}
+          style={{ width: "100%", height: 60, marginBottom: 6 }}
+        />
+      )}
+
      <Box mb={1.5} display="flex" alignItems="center" whiteSpace="nowrap">
        <ArrowUpward
          fontSize="small"
@@ -63,4 +83,4 @@ const Traffic = () => {
  );
 };

-export default Traffic;
+export default LayoutTraffic;
--- a/src/components/layout/update-button.tsx
+++ b/src/components/layout/update-button.tsx
--- a/src/components/layout/update-dialog.tsx
+++ b/src/components/layout/update-dialog.tsx
@@ -10,6 +10,7 @@ import {
  DialogContentText,
  DialogTitle,
 } from "@mui/material";
+import { killSidecars } from "../../services/cmds";

 interface Props {
  open: boolean;
@@ -31,6 +32,7 @@ const UpdateDialog = (props: Props) => {
    try {
      setUploading(true);
      uploadingState = true;
+      await killSidecars();
      await installUpdate();
      await relaunch();
    } catch (error) {
--- a/src/components/layout/use-traffic-graph.ts
+++ b/src/components/layout/use-traffic-graph.ts
@@ -0,0 +1,146 @@
+import { useRef } from "react";
+
+const minPoint = 10;
+const maxPoint = 36;
+
+const refLineAlpha = 0.5;
+const refLineWidth = 2;
+const refLineColor = "#ccc";
+
+const upLineAlpha = 0.6;
+const upLineWidth = 4;
+const upLineColor = "#9c27b0";
+
+const downLineAlpha = 1;
+const downLineWidth = 4;
+const downLineColor = "#5b5c9d";
+
+/**
+ * draw the traffic graph
+ */
+export default function useTrafficGraph() {
+  type TrafficData = { up: number; down: number };
+  const listRef = useRef<TrafficData[]>([]);
+  const styleRef = useRef(true);
+  const canvasRef = useRef<HTMLCanvasElement>(null!);
+
+  const drawGraph = () => {
+    const canvas = canvasRef.current!;
+
+    if (!canvas) return;
+
+    const context = canvas.getContext("2d")!;
+    const width = canvas.width;
+    const height = canvas.height;
+    const l1 = height * 0.2;
+    const l2 = height * 0.6;
+    const dl = height * 0.4;
+
+    context.clearRect(0, 0, width, height);
+
+    // Reference lines
+    context.beginPath();
+    context.globalAlpha = refLineAlpha;
+    context.lineWidth = refLineWidth;
+    context.strokeStyle = refLineColor;
+    context.moveTo(0, l1);
+    context.lineTo(width, l1);
+    context.moveTo(0, l2);
+    context.lineTo(width, l2);
+    context.stroke();
+    context.closePath();
+
+    const countY = (value: number) => {
+      let v = value;
+      if (v < 1024) v = (v / 1024) * dl;
+      else if (v < 1048576) v = dl + (v / 1048576) * dl;
+      else v = 2 * dl + (v / 10485760) * l1;
+      return height - v;
+    };
+
+    const drawBezier = (list: number[]) => {
+      const len = list.length;
+      const size = Math.min(Math.max(len, minPoint), maxPoint);
+      const axis = width / size;
+
+      let lx = 0;
+      let ly = height;
+      let llx = 0;
+      let lly = height;
+
+      list.forEach((val, index) => {
+        const x = (axis * index) | 0;
+        const y = countY(val);
+        const s = 0.25;
+
+        if (index === 0) context.moveTo(x, y);
+        else {
+          let nx = (axis * (index + 1)) | 0;
+          let ny = index < len - 1 ? countY(list[index + 1]) | 0 : 0;
+          const ax = (lx + (x - llx) * s) | 0;
+          const ay = (ly + (y - lly) * s) | 0;
+          const bx = (x - (nx - lx) * s) | 0;
+          const by = (y - (ny - ly) * s) | 0;
+          context.bezierCurveTo(ax, ay, bx, by, x, y);
+        }
+
+        llx = lx;
+        lly = ly;
+        lx = x;
+        ly = y;
+      });
+    };
+
+    const drawLine = (list: number[]) => {
+      const len = list.length;
+      const size = Math.min(Math.max(len, minPoint), maxPoint);
+      const axis = width / size;
+
+      list.forEach((val, index) => {
+        const x = (axis * index) | 0;
+        const y = countY(val);
+
+        if (index === 0) context.moveTo(x, y);
+        else context.lineTo(x, y);
+      });
+    };
+
+    const listUp = listRef.current.map((v) => v.up);
+    const listDown = listRef.current.map((v) => v.down);
+    const lineStyle = styleRef.current;
+
+    context.beginPath();
+    context.globalAlpha = upLineAlpha;
+    context.lineWidth = upLineWidth;
+    context.strokeStyle = upLineColor;
+    lineStyle ? drawLine(listUp) : drawBezier(listUp);
+    context.stroke();
+    context.closePath();
+
+    context.beginPath();
+    context.globalAlpha = downLineAlpha;
+    context.lineWidth = downLineWidth;
+    context.strokeStyle = downLineColor;
+    lineStyle ? drawLine(listDown) : drawBezier(listDown);
+    context.stroke();
+    context.closePath();
+  };
+
+  const appendData = (data: TrafficData) => {
+    const list = listRef.current;
+    if (list.length > maxPoint) list.shift();
+    list.push(data);
+    drawGraph();
+  };
+
+  const toggleStyle = () => {
+    styleRef.current = !styleRef.current;
+    drawGraph();
+  };
+
+  return {
+    canvasRef,
+    appendData,
+    toggleStyle,
+  };
+}
--- a/src/components/log/log-item.tsx
+++ b/src/components/log/log-item.tsx
@@ -1,5 +1,5 @@
 import { styled, Box } from "@mui/material";
-import { ApiType } from "../services/types";
+import { ApiType } from "../../services/types";

 const Item = styled(Box)(({ theme }) => ({
  padding: "8px 0",
--- a/src/components/profile/profile-item.tsx
+++ b/src/components/profile/profile-item.tsx
@@ -13,10 +13,10 @@ import {
 } from "@mui/material";
 import { useSWRConfig } from "swr";
 import { RefreshRounded } from "@mui/icons-material";
-import { CmdType } from "../services/types";
-import { updateProfile, deleteProfile, editProfile } from "../services/cmds";
-import Notice from "./notice";
-import parseTraffic from "../utils/parse-traffic";
+import { CmdType } from "../../services/types";
+import { updateProfile, deleteProfile, viewProfile } from "../../services/cmds";
+import Notice from "../base/base-notice";
+import parseTraffic from "../../utils/parse-traffic";
 import relativeTime from "dayjs/plugin/relativeTime";

 dayjs.extend(relativeTime);
@@ -59,10 +59,16 @@ const ProfileItem: React.FC<Props> = (props) => {
  const progress = Math.round(((download + upload) * 100) / (total + 0.1));
  const fromnow = updated > 0 ? dayjs(updated * 1000).fromNow() : "";

-  const onEdit = async () => {
+  // local file mode
+  // remote file mode
+  // subscription url mode
+  const hasUrl = !!itemData.url;
+  const hasExtra = !!extra; // only subscription url has extra info
+
+  const onView = async () => {
    setAnchorEl(null);
    try {
-      await editProfile(index);
+      await viewProfile(index);
    } catch (err: any) {
      Notice.error(err.toString());
    }
@@ -111,6 +117,26 @@ const ProfileItem: React.FC<Props> = (props) => {
    event.preventDefault();
  };

+  const boxStyle = {
+    height: 26,
+    display: "flex",
+    alignItems: "center",
+    justifyContent: "space-between",
+  };
+
+  const urlModeMenu = [
+    { label: "Select", handler: onForceSelect },
+    { label: "View", handler: onView },
+    { label: "Update", handler: onUpdateWrapper(false) },
+    { label: "Update(Proxy)", handler: onUpdateWrapper(true) },
+    { label: "Delete", handler: onDelete },
+  ];
+  const fileModeMenu = [
+    { label: "Select", handler: onForceSelect },
+    { label: "Edit", handler: onView },
+    { label: "Delete", handler: onDelete },
+  ];
+
  return (
    <>
      <Wrapper
@@ -155,52 +181,64 @@ const ProfileItem: React.FC<Props> = (props) => {
            {name}
          </Typography>

-          <IconButton
-            sx={{
-              width: 30,
-              height: 30,
-              animation: loading ? `1s linear infinite ${round}` : "none",
-            }}
-            color="inherit"
-            disabled={loading}
-            onClick={(e) => {
-              e.stopPropagation();
-              onUpdateWrapper(false)();
-            }}
-          >
-            <RefreshRounded />
-          </IconButton>
+          {/* only if has url can it be updated */}
+          {hasUrl && (
+            <IconButton
+              sx={{
+                width: 26,
+                height: 26,
+                animation: loading ? `1s linear infinite ${round}` : "none",
+              }}
+              color="inherit"
+              disabled={loading}
+              onClick={(e) => {
+                e.stopPropagation();
+                onUpdateWrapper(false)();
+              }}
+            >
+              <RefreshRounded />
+            </IconButton>
+          )}
        </Box>

-        <Box display="flex" justifyContent="space-between" alignItems="center">
-          <Typography noWrap title={`From: ${from}`}>
-            {from}
-          </Typography>
+        {/* the second line show url's info or description */}
+        {hasUrl ? (
+          <Box sx={boxStyle}>
+            <Typography noWrap title={`From: ${from}`}>
+              {from}
+            </Typography>

-          <Typography
-            noWrap
-            flex="1 0 auto"
-            fontSize={14}
-            textAlign="right"
-            title="updated time"
-          >
-            {fromnow}
-          </Typography>
-        </Box>
+            <Typography
+              noWrap
+              flex="1 0 auto"
+              fontSize={14}
+              textAlign="right"
+              title="updated time"
+            >
+              {fromnow}
+            </Typography>
+          </Box>
+        ) : (
+          <Box sx={boxStyle}>
+            <Typography noWrap title={itemData.desc}>
+              {itemData.desc}
+            </Typography>
+          </Box>
+        )}

-        <Box
-          sx={{
-            my: 0.5,
-            fontSize: 14,
-            display: "flex",
-            justifyContent: "space-between",
-          }}
-        >
-          <span title="used / total">
-            {parseTraffic(upload + download)} / {parseTraffic(total)}
-          </span>
-          <span title="expire time">{expire}</span>
-        </Box>
+        {/* the third line show extra info or last updated time */}
+        {hasExtra ? (
+          <Box sx={{ ...boxStyle, fontSize: 14 }}>
+            <span title="used / total">
+              {parseTraffic(upload + download)} / {parseTraffic(total)}
+            </span>
+            <span title="expire time">{expire}</span>
+          </Box>
+        ) : (
+          <Box sx={{ ...boxStyle, fontSize: 14, justifyContent: "flex-end" }}>
+            <span title="updated time">{parseExpire(updated)}</span>
+          </Box>
+        )}

        <LinearProgress
          variant="determinate"
@@ -216,11 +254,15 @@ const ProfileItem: React.FC<Props> = (props) => {
        anchorPosition={position}
        anchorReference="anchorPosition"
      >
-        <MenuItem onClick={onForceSelect}>Select</MenuItem>
-        <MenuItem onClick={onEdit}>Edit(VScode)</MenuItem>
-        <MenuItem onClick={onUpdateWrapper(false)}>Update</MenuItem>
-        <MenuItem onClick={onUpdateWrapper(true)}>Update(Proxy)</MenuItem>
-        <MenuItem onClick={onDelete}>Delete</MenuItem>
+        {(hasUrl ? urlModeMenu : fileModeMenu).map((item) => (
+          <MenuItem
+            key={item.label}
+            onClick={item.handler}
+            sx={{ minWidth: 133 }}
+          >
+            {item.label}
+          </MenuItem>
+        ))}
      </Menu>
    </>
  );
--- a/src/components/profile/profile-new.tsx
+++ b/src/components/profile/profile-new.tsx
@@ -0,0 +1,71 @@
+import { useEffect, useState } from "react";
+import {
+  Button,
+  Dialog,
+  DialogActions,
+  DialogContent,
+  DialogTitle,
+  TextField,
+} from "@mui/material";
+import Notice from "../base/base-notice";
+
+interface Props {
+  open: boolean;
+  onClose: () => void;
+  onSubmit: (name: string, desc: string) => void;
+}
+
+const ProfileNew = (props: Props) => {
+  const { open, onClose, onSubmit } = props;
+  const [name, setName] = useState("");
+  const [desc, setDesc] = useState("");
+
+  const onCreate = () => {
+    if (!name.trim()) {
+      Notice.error("`Name` should not be null");
+      return;
+    }
+    onSubmit(name, desc);
+  };
+
+  useEffect(() => {
+    if (!open) {
+      setName("");
+      setDesc("");
+    }
+  }, [open]);
+
+  return (
+    <Dialog open={open} onClose={onClose}>
+      <DialogTitle>Create Profile</DialogTitle>
+      <DialogContent sx={{ width: 320, pb: 0.5 }}>
+        <TextField
+          autoFocus
+          fullWidth
+          label="Name"
+          margin="dense"
+          variant="outlined"
+          value={name}
+          onChange={(e) => setName(e.target.value)}
+        />
+
+        <TextField
+          fullWidth
+          label="Descriptions"
+          margin="normal"
+          variant="outlined"
+          value={desc}
+          onChange={(e) => setDesc(e.target.value)}
+        />
+      </DialogContent>
+      <DialogActions sx={{ px: 2, pb: 2 }}>
+        <Button onClick={onClose}>Cancel</Button>
+        <Button onClick={onCreate} variant="contained">
+          Create
+        </Button>
+      </DialogActions>
+    </Dialog>
+  );
+};
+
+export default ProfileNew;
--- a/src/components/proxy-item.tsx
+++ b/src/components/proxy-item.tsx
@@ -1,58 +0,0 @@
-import { CheckCircleOutlineRounded } from "@mui/icons-material";
-import {
-  alpha,
-  ListItem,
-  ListItemButton,
-  ListItemIcon,
-  ListItemText,
-  SxProps,
-  Theme,
-} from "@mui/material";
-import { ApiType } from "../services/types";
-
-interface Props {
-  proxy: ApiType.ProxyItem;
-  selected: boolean;
-  sx?: SxProps<Theme>;
-  onClick?: (name: string) => void;
-}
-
-const ProxyItem = (props: Props) => {
-  const { proxy, selected, sx, onClick } = props;
-
-  return (
-    <ListItem sx={sx}>
-      <ListItemButton
-        dense
-        selected={selected}
-        onClick={() => onClick?.(proxy.name)}
-        sx={[
-          {
-            borderRadius: 1,
-          },
-          ({ palette: { mode, primary } }) => {
-            const bgcolor =
-              mode === "light"
-                ? alpha(primary.main, 0.15)
-                : alpha(primary.main, 0.35);
-            const color = mode === "light" ? primary.main : primary.light;
-
-            return {
-              "&.Mui-selected": { bgcolor },
-              "&.Mui-selected .MuiListItemText-secondary": { color },
-            };
-          },
-        ]}
-      >
-        <ListItemText title={proxy.name} secondary={proxy.name} />
-        <ListItemIcon
-          sx={{ justifyContent: "flex-end", color: "primary.main" }}
-        >
-          {selected && <CheckCircleOutlineRounded sx={{ fontSize: 16 }} />}
-        </ListItemIcon>
-      </ListItemButton>
-    </ListItem>
-  );
-};
-
-export default ProxyItem;
--- a/src/components/proxy/proxy-group.tsx
+++ b/src/components/proxy/proxy-group.tsx
@@ -1,4 +1,5 @@
-import { useState } from "react";
+import { useRef, useState } from "react";
+import { useSWRConfig } from "swr";
 import { Virtuoso } from "react-virtuoso";
 import {
  Box,
@@ -16,9 +17,10 @@ import {
  MyLocationRounded,
  NetworkCheckRounded,
 } from "@mui/icons-material";
-import { updateProxy } from "../services/api";
-import { ApiType } from "../services/types";
-import { getProfiles, patchProfile } from "../services/cmds";
+import { ApiType } from "../../services/types";
+import { updateProxy } from "../../services/api";
+import { getProfiles, patchProfile } from "../../services/cmds";
+import delayManager from "../../services/delay";
 import ProxyItem from "./proxy-item";

 interface Props {
@@ -26,25 +28,34 @@ interface Props {
 }

 const ProxyGroup = ({ group }: Props) => {
+  const { mutate } = useSWRConfig();
  const [open, setOpen] = useState(false);
  const [now, setNow] = useState(group.now);

+  const virtuosoRef = useRef<any>();
  const proxies = group.all ?? [];

-  const onUpdate = async (name: string) => {
-    // can not call update
-    if (group.type !== "Selector") {
-      // Todo
-      // error Tips
-      return;
-    }
+  const selectLockRef = useRef(false);
+  const onSelect = async (name: string) => {
+    // Todo: support another proxy group type
+    if (group.type !== "Selector") return;
+
+    if (selectLockRef.current) return;
+    selectLockRef.current = true;
+
    const oldValue = now;
    try {
      setNow(name);
      await updateProxy(group.name, name);
+    } catch {
+      setNow(oldValue);
+      return; // do not update profile
+    } finally {
+      selectLockRef.current = false;
+    }

-      const profiles = await getProfiles().catch(console.error);
-      if (!profiles) return;
+    try {
+      const profiles = await getProfiles();
      const profile = profiles.items![profiles.current!]!;
      if (!profile) return;
      if (!profile.selected) profile.selected = [];
@@ -58,15 +69,47 @@ const ProxyGroup = ({ group }: Props) => {
      } else {
        profile.selected[index] = { name: group.name, now: name };
      }
-
-      patchProfile(profiles.current!, profile).catch(console.error);
-    } catch {
-      setNow(oldValue);
-      // Todo
-      // error tips
+      await patchProfile(profiles.current!, profile);
+    } catch (err) {
+      console.error(err);
    }
  };

+  const onLocation = () => {
+    const index = proxies.findIndex((p) => p.name === now);
+
+    if (index >= 0) {
+      virtuosoRef.current?.scrollToIndex?.({
+        index,
+        align: "center",
+        behavior: "smooth",
+      });
+    }
+  };
+
+  const checkLockRef = useRef(false);
+  const onCheckAll = async () => {
+    if (checkLockRef.current) return;
+    checkLockRef.current = true;
+
+    // rerender quickly
+    if (proxies.length) setTimeout(() => mutate("getProxies"), 500);
+
+    let names = proxies.map((p) => p.name);
+    while (names.length) {
+      const list = names.slice(0, 8);
+      names = names.slice(8);
+
+      await Promise.all(
+        list.map((n) => delayManager.checkDelay(n, group.name))
+      );
+
+      mutate("getProxies");
+    }
+
+    checkLockRef.current = false;
+  };
+
  return (
    <>
      <ListItem button onClick={() => setOpen(!open)} dense>
@@ -88,24 +131,26 @@ const ProxyGroup = ({ group }: Props) => {

      <Collapse in={open} timeout="auto" unmountOnExit>
        <Box sx={{ pl: 4, pr: 3, my: 0.5 }}>
-          <IconButton size="small" title="location">
+          <IconButton size="small" title="location" onClick={onLocation}>
            <MyLocationRounded />
          </IconButton>
-          <IconButton size="small" title="check">
+          <IconButton size="small" title="check" onClick={onCheckAll}>
            <NetworkCheckRounded />
          </IconButton>
        </Box>

        {proxies.length >= 10 ? (
          <Virtuoso
+            ref={virtuosoRef}
            style={{ height: "320px", marginBottom: "4px" }}
            totalCount={proxies.length}
            itemContent={(index) => (
              <ProxyItem
+                groupName={group.name}
                proxy={proxies[index]}
                selected={proxies[index].name === now}
                sx={{ py: 0, pl: 4 }}
-                onClick={onUpdate}
+                onClick={onSelect}
              />
            )}
          />
@@ -118,10 +163,11 @@ const ProxyGroup = ({ group }: Props) => {
            {proxies.map((proxy) => (
              <ProxyItem
                key={proxy.name}
+                groupName={group.name}
                proxy={proxy}
                selected={proxy.name === now}
                sx={{ py: 0, pl: 4 }}
-                onClick={onUpdate}
+                onClick={onSelect}
              />
            ))}
          </List>
--- a/src/components/proxy/proxy-item.tsx
+++ b/src/components/proxy/proxy-item.tsx
@@ -0,0 +1,114 @@
+import { useEffect, useState } from "react";
+import { CheckCircleOutlineRounded } from "@mui/icons-material";
+import {
+  alpha,
+  Box,
+  ListItem,
+  ListItemButton,
+  ListItemIcon,
+  ListItemText,
+  styled,
+  SxProps,
+  Theme,
+} from "@mui/material";
+import { ApiType } from "../../services/types";
+import delayManager from "../../services/delay";
+
+interface Props {
+  groupName: string;
+  proxy: ApiType.ProxyItem;
+  selected: boolean;
+  sx?: SxProps<Theme>;
+  onClick?: (name: string) => void;
+}
+
+const Widget = styled(Box)(() => ({
+  padding: "4px 6px",
+  fontSize: 14,
+}));
+
+const ProxyItem = (props: Props) => {
+  const { groupName, proxy, selected, sx, onClick } = props;
+  const [delay, setDelay] = useState(-1);
+
+  useEffect(() => {
+    if (proxy) {
+      setDelay(delayManager.getDelay(proxy.name, groupName));
+    }
+  }, [proxy]);
+
+  const onDelay = (e: any) => {
+    e.preventDefault();
+    e.stopPropagation();
+
+    delayManager
+      .checkDelay(proxy.name, groupName)
+      .then((result) => setDelay(result))
+      .catch(() => setDelay(1e6));
+  };
+
+  return (
+    <ListItem sx={sx}>
+      <ListItemButton
+        dense
+        selected={selected}
+        onClick={() => onClick?.(proxy.name)}
+        sx={[
+          { borderRadius: 1 },
+          ({ palette: { mode, primary } }) => {
+            const bgcolor =
+              mode === "light"
+                ? alpha(primary.main, 0.15)
+                : alpha(primary.main, 0.35);
+            const color = mode === "light" ? primary.main : primary.light;
+
+            const showDelay = delay > 0;
+            const showIcon = !showDelay && selected;
+
+            return {
+              ".the-check": { display: "none" },
+              ".the-delay": { display: showDelay ? "block" : "none" },
+              ".the-icon": { display: showIcon ? "block" : "none" },
+              "&:hover .the-check": { display: !showDelay ? "block" : "none" },
+              "&:hover .the-delay": { display: showDelay ? "block" : "none" },
+              "&:hover .the-icon": { display: "none" },
+              "&.Mui-selected": { bgcolor },
+              "&.Mui-selected .MuiListItemText-secondary": { color },
+            };
+          },
+        ]}
+      >
+        <ListItemText title={proxy.name} secondary={proxy.name} />
+
+        <ListItemIcon
+          sx={{ justifyContent: "flex-end", color: "primary.main" }}
+        >
+          <Widget className="the-check" onClick={onDelay}>
+            Check
+          </Widget>
+
+          <Widget
+            className="the-delay"
+            onClick={onDelay}
+            color={
+              delay > 500
+                ? "error.main"
+                : delay < 100
+                ? "success.main"
+                : "text.secondary"
+            }
+          >
+            {delay > 1e5 ? "Error" : delay > 3000 ? "Timeout" : `${delay}ms`}
+          </Widget>
+
+          <CheckCircleOutlineRounded
+            className="the-icon"
+            sx={{ fontSize: 16 }}
+          />
+        </ListItemIcon>
+      </ListItemButton>
+    </ListItem>
+  );
+};
+
+export default ProxyItem;
--- a/src/components/setting/guard-state.tsx
+++ b/src/components/setting/guard-state.tsx
@@ -7,7 +7,7 @@ interface Props<Value> {
  onChangeProps?: string;
  onChange?: (value: Value) => void;
  onFormat?: (...args: any[]) => Value;
-  onGuard?: (value: Value) => Promise<void>;
+  onGuard?: (value: Value, oldValue: Value) => Promise<void>;
  onCatch?: (error: Error) => void;
  children: ReactNode;
 }
@@ -41,7 +41,7 @@ function GuardState<T>(props: Props<T>) {
        const newValue = (onFormat as any)(...args);
        // 先在ui上响应操作
        onChange(newValue);
-        await onGuard(newValue);
+        await onGuard(newValue, oldValue!);
      } catch (err: any) {
        // 状态回退
        onChange(oldValue!);
--- a/src/components/setting/setting-clash.tsx
+++ b/src/components/setting/setting-clash.tsx
@@ -1,3 +1,6 @@
+import { useEffect, useState } from "react";
+import { useDebounceFn } from "ahooks";
+import { useSetRecoilState } from "recoil";
 import useSWR, { useSWRConfig } from "swr";
 import {
  ListItemText,
@@ -5,15 +8,18 @@ import {
  Switch,
  Select,
  MenuItem,
+  Typography,
 } from "@mui/material";
-import { getClashConfig, updateConfigs } from "../../services/api";
-import { SettingList, SettingItem } from "./setting";
-import { patchClashConfig } from "../../services/cmds";
 import { ApiType } from "../../services/types";
+import { atomClashPort } from "../../states/setting";
+import { patchClashConfig } from "../../services/cmds";
+import { SettingList, SettingItem } from "./setting";
+import { getClashConfig, getVersion, updateConfigs } from "../../services/api";
+import Notice from "../base/base-notice";
 import GuardState from "./guard-state";

 interface Props {
-  onError?: (err: Error) => void;
+  onError: (err: Error) => void;
 }

 const SettingClash = ({ onError }: Props) => {
@@ -24,9 +30,14 @@ const SettingClash = ({ onError }: Props) => {
    ipv6 = false,
    "allow-lan": allowLan = false,
    "log-level": logLevel = "silent",
-    "mixed-port": mixedPort = 7890,
+    "mixed-port": thePort = 0,
  } = clashConfig ?? {};

+  const setPort = useSetRecoilState(atomClashPort);
+  const [mixedPort, setMixedPort] = useState(thePort);
+
+  useEffect(() => setMixedPort(thePort), [thePort]);
+
  const onSwitchFormat = (_e: any, value: boolean) => value;
  const onChangeData = (patch: Partial<ApiType.ConfigData>) => {
    mutate("getClashConfig", { ...clashConfig, ...patch }, false);
@@ -36,6 +47,36 @@ const SettingClash = ({ onError }: Props) => {
    await patchClashConfig(patch);
  };

+  // restart clash when port is changed
+  const { run: onUpdatePort } = useDebounceFn(
+    async (port: number) => {
+      try {
+        if (port < 1000) {
+          throw new Error("The port should not < 1000");
+        }
+        if (port > 65536) {
+          throw new Error("The port should not > 65536");
+        }
+        await patchClashConfig({ "mixed-port": port });
+        onChangeData({ "mixed-port": port });
+        setPort(port);
+        Notice.success("Change Clash port successfully!");
+      } catch (err: any) {
+        setMixedPort(thePort); // back to old port value
+        Notice.error(err.message ?? err.toString());
+      }
+    },
+    { wait: 1000 }
+  );
+
+  // get clash core version
+  const [clashVer, setClashVer] = useState("");
+  useEffect(() => {
+    getVersion().then(({ premium, version }) => {
+      setClashVer(premium ? `${version} Premium` : version);
+    });
+  }, []);
+
  return (
    <SettingList title="Clash Setting">
      <SettingItem>
@@ -87,12 +128,19 @@ const SettingClash = ({ onError }: Props) => {

      <SettingItem>
        <ListItemText primary="Mixed Port" />
-        <TextField
-          size="small"
+        <GuardState
          value={mixedPort!}
-          sx={{ width: 120 }}
-          disabled
-        />
+          onFormat={(e: any) => +e.target.value?.replace(/\D+/, "")}
+          onChange={setMixedPort}
+          onGuard={onUpdatePort}
+        >
+          <TextField autoComplete="off" size="small" sx={{ width: 120 }} />
+        </GuardState>
+      </SettingItem>
+
+      <SettingItem>
+        <ListItemText primary="Clash core" />
+        <Typography sx={{ py: 1 }}>{clashVer}</Typography>
      </SettingItem>
    </SettingList>
  );
--- a/src/components/setting/setting-system.tsx
+++ b/src/components/setting/setting-system.tsx
@@ -1,5 +1,5 @@
 import useSWR, { useSWRConfig } from "swr";
-import { Box, ListItemText, Switch } from "@mui/material";
+import { Box, ListItemText, Switch, TextField } from "@mui/material";
 import { getVergeConfig, patchVergeConfig } from "../../services/cmds";
 import { SettingList, SettingItem } from "./setting";
 import { CmdType } from "../../services/types";
@@ -15,8 +15,10 @@ const SettingSystem = ({ onError }: Props) => {
  const { data: vergeConfig } = useSWR("getVergeConfig", getVergeConfig);

  const {
-    enable_auto_launch: startup = false,
-    enable_system_proxy: proxy = false,
+    enable_auto_launch = false,
+    enable_system_proxy = false,
+    system_proxy_bypass = "",
+    enable_proxy_guard = false,
  } = vergeConfig ?? {};

  const onSwitchFormat = (_e: any, value: boolean) => value;
@@ -29,7 +31,7 @@ const SettingSystem = ({ onError }: Props) => {
      <SettingItem>
        <ListItemText primary="Auto Launch" />
        <GuardState
-          value={startup}
+          value={enable_auto_launch}
          valueProps="checked"
          onCatch={onError}
          onFormat={onSwitchFormat}
@@ -50,16 +52,50 @@ const SettingSystem = ({ onError }: Props) => {
          }
        />
        <GuardState
-          value={proxy}
+          value={enable_system_proxy}
          valueProps="checked"
          onCatch={onError}
          onFormat={onSwitchFormat}
          onChange={(e) => onChangeData({ enable_system_proxy: e })}
-          onGuard={(e) => patchVergeConfig({ enable_system_proxy: e })}
+          onGuard={async (e) => {
+            await patchVergeConfig({ enable_system_proxy: e });
+            mutate("getVergeConfig"); // update bypass value
+          }}
        >
          <Switch edge="end" />
        </GuardState>
      </SettingItem>
+
+      {enable_system_proxy && (
+        <SettingItem>
+          <ListItemText primary="Proxy Guard" />
+          <GuardState
+            value={enable_proxy_guard}
+            valueProps="checked"
+            onCatch={onError}
+            onFormat={onSwitchFormat}
+            onChange={(e) => onChangeData({ enable_proxy_guard: e })}
+            onGuard={(e) => patchVergeConfig({ enable_proxy_guard: e })}
+          >
+            <Switch edge="end" />
+          </GuardState>
+        </SettingItem>
+      )}
+
+      {enable_system_proxy && (
+        <SettingItem>
+          <ListItemText primary="Proxy Bypass" />
+          <GuardState
+            value={system_proxy_bypass ?? ""}
+            onCatch={onError}
+            onFormat={(e: any) => e.target.value}
+            onChange={(e) => onChangeData({ system_proxy_bypass: e })}
+            onGuard={(e) => patchVergeConfig({ system_proxy_bypass: e })}
+          >
+            <TextField autoComplete="off" size="small" sx={{ width: 120 }} />
+          </GuardState>
+        </SettingItem>
+      )}
    </SettingList>
  );
 };
--- a/src/components/setting/setting-verge.tsx
+++ b/src/components/setting/setting-verge.tsx
@@ -1,11 +1,17 @@
 import useSWR, { useSWRConfig } from "swr";
-import { ListItemText, Switch, Typography } from "@mui/material";
-import { getVergeConfig, patchVergeConfig } from "../../services/cmds";
+import { IconButton, ListItemText, Switch, Typography } from "@mui/material";
+import {
+  getVergeConfig,
+  openAppDir,
+  openLogsDir,
+  patchVergeConfig,
+} from "../../services/cmds";
+import { ArrowForward } from "@mui/icons-material";
 import { SettingList, SettingItem } from "./setting";
 import { CmdType } from "../../services/types";
 import { version } from "../../../package.json";
-import GuardState from "./guard-state";
 import PaletteSwitch from "./palette-switch";
+import GuardState from "./guard-state";

 interface Props {
  onError?: (err: Error) => void;
@@ -15,7 +21,7 @@ const SettingVerge = ({ onError }: Props) => {
  const { mutate } = useSWRConfig();
  const { data: vergeConfig } = useSWR("getVergeConfig", getVergeConfig);

-  const { theme_mode: mode = "light", theme_blur: blur = false } =
+  const { theme_mode = "light", theme_blur = false, traffic_graph } =
    vergeConfig ?? {};

  const onSwitchFormat = (_e: any, value: boolean) => value;
@@ -28,13 +34,13 @@ const SettingVerge = ({ onError }: Props) => {
      <SettingItem>
        <ListItemText primary="Theme Mode" />
        <GuardState
-          value={mode === "dark"}
+          value={theme_mode === "dark"}
          valueProps="checked"
          onCatch={onError}
          onFormat={onSwitchFormat}
          onChange={(e) => onChangeData({ theme_mode: e ? "dark" : "light" })}
-          onGuard={(c) =>
-            patchVergeConfig({ theme_mode: c ? "dark" : "light" })
+          onGuard={(e) =>
+            patchVergeConfig({ theme_mode: e ? "dark" : "light" })
          }
        >
          <PaletteSwitch edge="end" />
@@ -44,7 +50,7 @@ const SettingVerge = ({ onError }: Props) => {
      <SettingItem>
        <ListItemText primary="Theme Blur" />
        <GuardState
-          value={blur}
+          value={theme_blur}
          valueProps="checked"
          onCatch={onError}
          onFormat={onSwitchFormat}
@@ -55,6 +61,34 @@ const SettingVerge = ({ onError }: Props) => {
        </GuardState>
      </SettingItem>

+      <SettingItem>
+        <ListItemText primary="Traffic Graph" />
+        <GuardState
+          value={traffic_graph ?? true}
+          valueProps="checked"
+          onCatch={onError}
+          onFormat={onSwitchFormat}
+          onChange={(e) => onChangeData({ traffic_graph: e })}
+          onGuard={(e) => patchVergeConfig({ traffic_graph: e })}
+        >
+          <Switch edge="end" />
+        </GuardState>
+      </SettingItem>
+
+      <SettingItem>
+        <ListItemText primary="Open App Dir" />
+        <IconButton color="inherit" size="small" onClick={openAppDir}>
+          <ArrowForward />
+        </IconButton>
+      </SettingItem>
+
+      <SettingItem>
+        <ListItemText primary="Open Logs Dir" />
+        <IconButton color="inherit" size="small" onClick={openLogsDir}>
+          <ArrowForward />
+        </IconButton>
+      </SettingItem>
+
      <SettingItem>
        <ListItemText primary="Version" />
        <Typography sx={{ py: "6px" }}>v{version}</Typography>
--- a/src/pages/_layout.tsx
+++ b/src/pages/_layout.tsx
@@ -1,34 +1,41 @@
-import useSWR, { SWRConfig } from "swr";
+import useSWR, { SWRConfig, useSWRConfig } from "swr";
 import { useEffect, useMemo } from "react";
 import { Route, Routes } from "react-router-dom";
-import { useRecoilState } from "recoil";
 import { alpha, createTheme, List, Paper, ThemeProvider } from "@mui/material";
+import { listen } from "@tauri-apps/api/event";
 import { appWindow } from "@tauri-apps/api/window";
-import { atomPaletteMode, atomThemeBlur } from "../states/setting";
-import { getVergeConfig } from "../services/cmds";
 import { routers } from "./_routers";
+import { getAxios } from "../services/api";
+import { getVergeConfig } from "../services/cmds";
 import LogoSvg from "../assets/image/logo.svg";
-import Traffic from "../components/traffic";
-import LayoutItem from "../components/layout-item";
-import UpdateButton from "../components/update-button";
-import LayoutControl from "../components/layout-control";
+import LayoutItem from "../components/layout/layout-item";
+import LayoutControl from "../components/layout/layout-control";
+import LayoutTraffic from "../components/layout/layout-traffic";
+import UpdateButton from "../components/layout/update-button";
+
+const isMacos = navigator.userAgent.includes("Mac OS X");

 const Layout = () => {
-  const [mode, setMode] = useRecoilState(atomPaletteMode);
-  const [blur, setBlur] = useRecoilState(atomThemeBlur);
-  const { data: vergeConfig } = useSWR("getVergeConfig", getVergeConfig);
+  const { mutate } = useSWRConfig();
+  const { data } = useSWR("getVergeConfig", getVergeConfig);
+
+  const blur = !!data?.theme_blur;
+  const mode = data?.theme_mode ?? "light";

  useEffect(() => {
    window.addEventListener("keydown", (e) => {
      if (e.key === "Escape") appWindow.hide();
    });
-  }, []);

-  useEffect(() => {
-    if (!vergeConfig) return;
-    setBlur(!!vergeConfig.theme_blur);
-    setMode(vergeConfig.theme_mode ?? "light");
-  }, [vergeConfig]);
+    listen("restart_clash", async () => {
+      // the clash info may be updated
+      await getAxios(true);
+      // make sure that the clash is ok
+      setTimeout(() => mutate("getProxies"), 1000);
+      setTimeout(() => mutate("getProxies"), 2000);
+      mutate("getClashConfig");
+    });
+  }, []);

  const theme = useMemo(() => {
    // const background = mode === "light" ? "#f5f5f5" : "#000";
@@ -62,7 +69,7 @@ const Layout = () => {
        <Paper
          square
          elevation={0}
-          className="layout"
+          className={`${isMacos ? "macos " : ""}layout`}
          onPointerDown={onDragging}
          sx={[
            (theme) => ({
@@ -86,16 +93,18 @@ const Layout = () => {
            </List>

            <div className="the-traffic" data-windrag>
-              <Traffic />
+              <LayoutTraffic />
            </div>
          </div>

          <div className="layout__right" data-windrag>
-            <div className="the-bar">
-              <LayoutControl />
-            </div>
+            {!isMacos && (
+              <div className="the-bar">
+                <LayoutControl />
+              </div>
+            )}

-            <div className="the-content" data-windrag>
+            <div className="the-content">
              <Routes>
                {routers.map(({ label, link, ele: Ele }) => (
                  <Route key={label} path={link} element={<Ele />} />
--- a/src/pages/connections.tsx
+++ b/src/pages/connections.tsx
@@ -3,8 +3,8 @@ import { Paper } from "@mui/material";
 import { Virtuoso } from "react-virtuoso";
 import { ApiType } from "../services/types";
 import { getInfomation } from "../services/api";
-import BasePage from "../components/base-page";
-import ConnectionItem from "../components/connection-item";
+import BasePage from "../components/base/base-page";
+import ConnectionItem from "../components/connection/connection-item";

 const ConnectionsPage = () => {
  const initConn = { uploadTotal: 0, downloadTotal: 0, connections: [] };
--- a/src/pages/logs.tsx
+++ b/src/pages/logs.tsx
@@ -4,8 +4,8 @@ import { Button, Paper } from "@mui/material";
 import { Virtuoso } from "react-virtuoso";
 import { ApiType } from "../services/types";
 import { getInfomation } from "../services/api";
-import BasePage from "../components/base-page";
-import LogItem from "../components/log-item";
+import BasePage from "../components/base/base-page";
+import LogItem from "../components/log/log-item";

 let logCache: ApiType.LogItem[] = [];

--- a/src/pages/profiles.tsx
+++ b/src/pages/profiles.tsx
@@ -6,12 +6,14 @@ import {
  selectProfile,
  patchProfile,
  importProfile,
+  newProfile,
 } from "../services/cmds";
 import { getProxies, updateProxy } from "../services/api";
 import noop from "../utils/noop";
-import Notice from "../components/notice";
-import BasePage from "../components/base-page";
-import ProfileItem from "../components/profile-item";
+import Notice from "../components/base/base-notice";
+import BasePage from "../components/base/base-page";
+import ProfileItem from "../components/profile/profile-item";
+import ProfileNew from "../components/profile/profile-new";

 const ProfilePage = () => {
  const [url, setUrl] = useState("");
@@ -94,6 +96,23 @@ const ProfilePage = () => {
    }
  };

+  const lockNewRef = useRef(false);
+  const [dialogOpen, setDialogOpen] = useState(false);
+  const onNew = async (name: string, desc: string) => {
+    if (lockNewRef.current) return;
+    lockNewRef.current = true;
+
+    try {
+      await newProfile(name, desc);
+      setDialogOpen(false);
+      mutate("getProfiles");
+    } catch (err: any) {
+      err && Notice.error(err.toString());
+    } finally {
+      lockNewRef.current = false;
+    }
+  };
+
  return (
    <BasePage title="Profiles">
      <Box sx={{ display: "flex", mb: 3 }}>
@@ -105,15 +124,19 @@ const ProfilePage = () => {
          fullWidth
          value={url}
          onChange={(e) => setUrl(e.target.value)}
-          sx={{ mr: 2 }}
+          sx={{ mr: 1 }}
        />
        <Button
          disabled={!url || disabled}
          variant="contained"
          onClick={onImport}
+          sx={{ mr: 1 }}
        >
          Import
        </Button>
+        <Button variant="contained" onClick={() => setDialogOpen(true)}>
+          New
+        </Button>
      </Box>

      <Grid container spacing={3}>
@@ -128,6 +151,12 @@ const ProfilePage = () => {
          </Grid>
        ))}
      </Grid>
+
+      <ProfileNew
+        open={dialogOpen}
+        onClose={() => setDialogOpen(false)}
+        onSubmit={onNew}
+      />
    </BasePage>
  );
 };
--- a/src/pages/proxies.tsx
+++ b/src/pages/proxies.tsx
@@ -1,46 +1,127 @@
 import useSWR, { useSWRConfig } from "swr";
-import { useEffect } from "react";
-import { List, Paper } from "@mui/material";
+import { useEffect, useMemo, useRef, useState } from "react";
+import { Virtuoso } from "react-virtuoso";
+import { Button, ButtonGroup, List, Paper } from "@mui/material";
+import { getClashConfig, updateConfigs, updateProxy } from "../services/api";
+import { patchClashConfig } from "../services/cmds";
 import { getProxies } from "../services/api";
-import BasePage from "../components/base-page";
-import ProxyItem from "../components/proxy-item";
-import ProxyGroup from "../components/proxy-group";
+import BasePage from "../components/base/base-page";
+import ProxyItem from "../components/proxy/proxy-item";
+import ProxyGroup from "../components/proxy/proxy-group";

 const ProxyPage = () => {
  const { mutate } = useSWRConfig();
  const { data: proxiesData } = useSWR("getProxies", getProxies);
-  const { groups = [], proxies = [] } = proxiesData ?? {};
+  const { data: clashConfig } = useSWR("getClashConfig", getClashConfig);
+  const [curProxy, setCurProxy] = useState<string>("DIRECT");
+  const curMode = clashConfig?.mode.toLowerCase();

+  // proxy groups
+  const { groups = [] } = proxiesData ?? {};
+  // proxies and sorted
+  const filterProxies = useMemo(() => {
+    if (!proxiesData?.proxies) return [];
+
+    const list = Object.values(proxiesData.proxies);
+    const retList = list.filter(
+      (p) => !p.all?.length && p.name !== "DIRECT" && p.name !== "REJECT"
+    );
+    const direct = list.filter((p) => p.name === "DIRECT");
+    const reject = list.filter((p) => p.name === "REJECT");
+
+    return direct.concat(retList).concat(reject);
+  }, [proxiesData]);
+
+  const modeList = ["rule", "global", "direct"];
+  const asGroup = curMode === "rule" && groups.length;
+
+  // make sure that fetch the proxies successfully
  useEffect(() => {
-    // fix the empty proxies on the first sight
-    // this bud only show on the build version
-    // call twice to avoid something unknown or the delay of the clash startup
-    setTimeout(() => mutate("getProxies"), 250);
-    setTimeout(() => mutate("getProxies"), 1000);
-  }, []);
+    if (
+      (curMode === "rule" && !groups.length) ||
+      (curMode === "global" && filterProxies.length < 4)
+    ) {
+      setTimeout(() => mutate("getProxies"), 500);
+    }
+  }, [groups, filterProxies, curMode]);
+
+  // update the current proxy
+  useEffect(() => {
+    if (curMode === "direct") setCurProxy("DIRECT");
+    if (curMode === "global") {
+      const globalNow = proxiesData?.proxies?.GLOBAL?.now;
+      setCurProxy(globalNow || "DIRECT");
+    }
+  }, [curMode, proxiesData]);
+
+  const changeLockRef = useRef(false);
+  const onChangeMode = async (mode: string) => {
+    if (changeLockRef.current) return;
+    changeLockRef.current = true;
+
+    try {
+      // switch rapidly
+      await updateConfigs({ mode });
+      await patchClashConfig({ mode });
+      mutate("getClashConfig");
+    } finally {
+      changeLockRef.current = false;
+    }
+  };
+
+  const onChangeProxy = async (name: string) => {
+    if (curMode !== "global") return;
+    await updateProxy("GLOBAL", name);
+    setCurProxy(name);
+  };
+
+  // difference style
+  const pageStyle = asGroup ? {} : { height: "100%" };
+  const paperStyle: any = asGroup
+    ? { mb: 0.5 }
+    : { py: 1, height: "100%", boxSizing: "border-box" };

  return (
-    <BasePage title={groups.length ? "Proxy Groups" : "Proxies"}>
-      <Paper sx={{ borderRadius: 1, boxShadow: 2, mb: 1 }}>
-        {groups.length > 0 && (
+    <BasePage
+      contentStyle={pageStyle}
+      title={asGroup ? "Proxy Groups" : "Proxies"}
+      header={
+        <ButtonGroup size="small">
+          {modeList.map((mode) => (
+            <Button
+              key={mode}
+              variant={mode === curMode ? "contained" : "outlined"}
+              onClick={() => onChangeMode(mode)}
+              sx={{ textTransform: "capitalize" }}
+            >
+              {mode}
+            </Button>
+          ))}
+        </ButtonGroup>
+      }
+    >
+      <Paper sx={{ borderRadius: 1, boxShadow: 2, ...paperStyle }}>
+        {asGroup ? (
          <List>
            {groups.map((group) => (
              <ProxyGroup key={group.name} group={group} />
            ))}
          </List>
-        )}
-
-        {!groups.length && (
-          <List>
-            {Object.values(proxies).map((proxy) => (
+        ) : (
+          // virtual list
+          <Virtuoso
+            style={{ height: "100%" }}
+            totalCount={filterProxies.length}
+            itemContent={(index) => (
              <ProxyItem
-                key={proxy.name}
-                proxy={proxy}
-                selected={false}
+                groupName="GLOBAL"
+                proxy={filterProxies[index]}
+                selected={filterProxies[index].name === curProxy}
+                onClick={onChangeProxy}
                sx={{ py: 0, px: 2 }}
              />
-            ))}
-          </List>
+            )}
+          />
        )}
      </Paper>
    </BasePage>
--- a/src/pages/settings.tsx
+++ b/src/pages/settings.tsx
@@ -1,9 +1,9 @@
 import { Paper } from "@mui/material";
-import BasePage from "../components/base-page";
+import Notice from "../components/base/base-notice";
+import BasePage from "../components/base/base-page";
 import SettingVerge from "../components/setting/setting-verge";
 import SettingClash from "../components/setting/setting-clash";
 import SettingSystem from "../components/setting/setting-system";
-import Notice from "../components/notice";

 const SettingPage = () => {
  const onError = (error: any) => {
--- a/src/services/api.ts
+++ b/src/services/api.ts
@@ -7,8 +7,9 @@ let server = "";
 let secret = "";

 /// initialize some infomation
-export async function getAxios() {
-  if (axiosIns) return axiosIns;
+/// enable force update axiosIns
+export async function getAxios(force: boolean = false) {
+  if (axiosIns && !force) return axiosIns;

  try {
    const info = await getClashInfo();
@@ -59,10 +60,24 @@ export async function getRules() {
  return instance.get("/rules") as Promise<ApiType.RuleItem[]>;
 }

+/// Get Proxy delay
+export async function getProxyDelay(
+  name: string,
+  url?: string
+): Promise<{ delay: number }> {
+  const params = {
+    timeout: 3000,
+    url: url || "http://www.gstatic.com/generate_204",
+  };
+
+  const instance = await getAxios();
+  return instance.get(`/proxies/${encodeURIComponent(name)}/delay`, { params });
+}
+
 /// Update the Proxy Choose
 export async function updateProxy(group: string, proxy: string) {
  const instance = await getAxios();
-  return instance.put(`/proxies/${group}`, { name: proxy });
+  return instance.put(`/proxies/${encodeURIComponent(group)}`, { name: proxy });
 }

 /// Get the Proxy infomation
--- a/src/services/cmds.ts
+++ b/src/services/cmds.ts
@@ -9,8 +9,12 @@ export async function syncProfiles() {
  return invoke<void>("sync_profiles");
 }

-export async function editProfile(index: number) {
-  return invoke<void>("edit_profile", { index });
+export async function newProfile(name: string, desc: string) {
+  return invoke<void>("new_profile", { name, desc });
+}
+
+export async function viewProfile(index: number) {
+  return invoke<void>("view_profile", { index });
 }

 export async function importProfile(url: string) {
@@ -59,3 +63,15 @@ export async function patchVergeConfig(payload: CmdType.VergeConfig) {
 export async function getSystemProxy() {
  return invoke<any>("get_sys_proxy");
 }
+
+export async function killSidecars() {
+  return invoke<any>("kill_sidecars");
+}
+
+export async function openAppDir() {
+  return invoke<void>("open_app_dir");
+}
+
+export async function openLogsDir() {
+  return invoke<void>("open_logs_dir");
+}
--- a/src/services/delay.ts
+++ b/src/services/delay.ts
@@ -0,0 +1,37 @@
+import { getProxyDelay } from "./api";
+
+const hashKey = (name: string, group: string) => `${group ?? ""}::${name}`;
+
+class DelayManager {
+  private cache = new Map<string, [number, number]>();
+
+  setDelay(name: string, group: string, delay: number) {
+    this.cache.set(hashKey(name, group), [Date.now(), delay]);
+  }
+
+  getDelay(name: string, group: string) {
+    if (!name) return -1;
+
+    const result = this.cache.get(hashKey(name, group));
+    if (result && Date.now() - result[0] <= 18e5) {
+      return result[1];
+    }
+    return -1;
+  }
+
+  async checkDelay(name: string, group: string) {
+    let delay = -1;
+
+    try {
+      const result = await getProxyDelay(name);
+      delay = result.delay;
+    } catch {
+      delay = 1e6; // error
+    }
+
+    this.setDelay(name, group, delay);
+    return delay;
+  }
+}
+
+export default new DelayManager();
--- a/src/services/types.ts
+++ b/src/services/types.ts
@@ -87,6 +87,7 @@ export namespace CmdType {

  export interface ProfileItem {
    name?: string;
+    desc?: string;
    file?: string;
    mode?: string;
    url?: string;
@@ -111,7 +112,10 @@ export namespace CmdType {
  export interface VergeConfig {
    theme_mode?: "light" | "dark";
    theme_blur?: boolean;
+    traffic_graph?: boolean;
    enable_auto_launch?: boolean;
    enable_system_proxy?: boolean;
+    enable_proxy_guard?: boolean;
+    system_proxy_bypass?: string;
  }
 }
--- a/src/states/setting.ts
+++ b/src/states/setting.ts
@@ -1,11 +1,6 @@
 import { atom } from "recoil";

-export const atomPaletteMode = atom<"light" | "dark">({
-  key: "atomPaletteMode",
-  default: "light",
-});
-
-export const atomThemeBlur = atom<boolean>({
-  key: "atomThemeBlur",
-  default: false,
+export const atomClashPort = atom<number>({
+  key: "atomClashPort",
+  default: 0,
 });
--- a/yarn.lock
+++ b/yarn.lock
Author	SHA1	Message	Date
GyDi	1ad3ddef94	v0.0.16	2022-02-21 01:33:11 +08:00
GyDi	97ec5eabf7	feat: change window style	2022-02-20 23:46:13 +08:00
GyDi	e12e3a3f2d	feat: fill verge template	2022-02-20 20:12:55 +08:00
GyDi	4ff625f23b	feat: enable customize guard duration	2022-02-20 20:11:39 +08:00
GyDi	e38dcd85ac	feat: system proxy guard	2022-02-20 18:53:21 +08:00
GyDi	0245baf1b6	feat: enable show or hide traffic graph	2022-02-19 18:14:40 +08:00
GyDi	10b55c043c	fix: patch verge config	2022-02-19 17:32:23 +08:00
GyDi	457655b416	feat: traffic line graph	2022-02-19 17:02:24 +08:00
GyDi	7e4506c860	chore: update deps	2022-02-19 00:34:09 +08:00
GyDi	794d376348	feat: adjust profile item ui	2022-02-19 00:23:47 +08:00
GyDi	c60578f5b5	feat: adjust fetch profile url	2022-02-19 00:09:36 +08:00
GyDi	3a9a392a77	feat: inline config file template	2022-02-18 23:57:13 +08:00
GyDi	a13d4698be	chore: update check script	2022-02-18 23:49:39 +08:00
GyDi	c046a1993e	fix: fetch profile panic	2022-02-17 13:44:26 +08:00
GyDi	f709117cc4	feat: kill sidecars when update app	2022-02-17 02:10:25 +08:00
GyDi	30dd298fca	feat: delete file	2022-02-17 01:58:12 +08:00
GyDi	0ff8bb8090	feat: lock some async functions	2022-02-17 01:42:25 +08:00
GyDi	74bbd3c3a2	chore: tauri updater env	2022-02-16 11:02:00 +08:00
GyDi	2e82eaf59a	chore: add pubkey	2022-02-16 10:59:31 +08:00
GyDi	7f1df1f1bd	v0.0.15	2022-02-16 03:22:25 +08:00
GyDi	3c79238a44	feat: support open dir	2022-02-16 03:21:34 +08:00
GyDi	0aa2565df3	fix: spawn command	2022-02-16 02:43:52 +08:00
GyDi	22b11db16e	feat: change allow list	2022-02-16 02:42:56 +08:00
GyDi	d0e678b5e9	feat: support check delay	2022-02-16 02:22:01 +08:00
GyDi	e7bba968b3	fix: import error	2022-02-15 01:36:19 +08:00
GyDi	4934a24293	feat: scroll to proxy item	2022-02-15 01:34:10 +08:00
GyDi	ccb68bcda9	chore: update deps	2022-02-15 00:33:58 +08:00
GyDi	66bf4ba3ad	fix: not open file when new profile	2022-02-15 00:21:34 +08:00
GyDi	78a0cfd052	feat: edit system proxy bypass	2022-02-14 01:26:24 +08:00
GyDi	8548373742	feat: disable user select	2022-02-13 19:52:35 +08:00
GyDi	2dfd725ee0	fix: reset value correctly	2022-02-13 19:40:31 +08:00
GyDi	5b779b4f14	feat: new profile able to edit name and desc	2022-02-13 19:33:24 +08:00
GyDi	fc48aa7155	chore: adjust files	2022-02-13 19:27:24 +08:00
GyDi	6193a842f4	feat: update tauri version	2022-02-13 18:45:03 +08:00
GyDi	eb86b471fe	fix: something	2022-02-12 21:12:39 +08:00
GyDi	2b52584547	fix: menu without fragment	2022-02-10 01:42:52 +08:00
GyDi	6e3cc57f48	feat: display clash core version	2022-02-10 01:35:55 +08:00
GyDi	f2c04621a5	feat: adjust profile item menu	2022-02-10 01:14:57 +08:00
GyDi	3ed6938d4a	v0.0.14	2022-02-09 02:11:01 +08:00
GyDi	99fec25ed5	feat: profile item ui	2022-02-09 02:08:27 +08:00
GyDi	73758ad1fd	fix: proxy list error	2022-02-09 02:02:29 +08:00
GyDi	c53fe0ed1f	feat: support new profile	2022-02-07 17:26:05 +08:00
GyDi	6082c2bcac	feat: support open command for viewing	2022-02-07 16:45:20 +08:00
GyDi	069abed784	chore: add item template yaml	2022-02-02 20:56:06 +08:00
GyDi	7d8fa4d78a	fix: something	2022-01-31 23:34:58 +08:00
GyDi	76081f8d89	fix: macos auto launch fail	2022-01-31 23:32:41 +08:00
GyDi	5ef4285558	chore: update deps and app name	2022-01-31 23:27:11 +08:00
GyDi	aa7df4282e	chore: cargo update	2022-01-28 22:02:17 +08:00
GyDi	0ef1d5d0de	chore: update clash version	2022-01-28 22:00:15 +08:00
GyDi	cceb4bb81f	v0.0.13	2022-01-25 02:11:00 +08:00
GyDi	f0f45e007d	feat: global proxies use virtual list	2022-01-25 02:08:10 +08:00
GyDi	6a8ffe1642	feat: enable change proxy mode	2022-01-25 01:51:44 +08:00
GyDi	3a73868c10	feat: update styles	2022-01-25 01:48:26 +08:00
GyDi	ab1b5897a6	feat: manage clash mode	2022-01-24 23:13:13 +08:00
GyDi	f94734a5c8	chore: update readme	2022-01-22 23:57:39 +08:00
GyDi	61b86c9584	v0.0.12	2022-01-21 03:09:21 +08:00
GyDi	1ac1d6e903	chore: update ci	2022-01-21 03:08:40 +08:00
GyDi	b6c58f74c0	fix: type error	2022-01-21 03:08:20 +08:00
GyDi	c88e99d87c	v0.0.12	2022-01-21 02:59:33 +08:00
GyDi	8d7ab9d05e	refactor: rename profiles & command state	2022-01-21 02:57:15 +08:00
GyDi	47155a4a29	feat: change system porxy when changed port	2022-01-21 02:50:13 +08:00
GyDi	d0b87fd7c3	feat: enable change mixed port	2022-01-21 02:32:23 +08:00
GyDi	d49fd37656	feat: manage clash config	2022-01-21 02:31:44 +08:00
GyDi	0bd29d71be	chore: add ahooks	2022-01-21 02:29:45 +08:00
GyDi	4b5b62c8ae	fix: restart clash should update something	2022-01-21 00:29:33 +08:00
GyDi	65fb2ca2d5	feat: enable update clash info	2022-01-20 23:41:08 +08:00
GyDi	0d5bfc0997	feat: rename edit as view	2022-01-19 23:58:34 +08:00
GyDi	4f02c373c2	chore: adjust ci	2022-01-19 23:55:05 +08:00
GyDi	209a5b1207	fix: script error...	2022-01-19 00:49:23 +08:00
GyDi	95349eacab	fix: tag error	2022-01-19 00:46:43 +08:00
GyDi	82ba604b99	fix: script error	2022-01-19 00:42:37 +08:00
GyDi	46a8dec655	feat: test auto gen update.json ci	2022-01-19 00:37:59 +08:00