[🚧 Fix] <PLS & FS> Improve PLS download logic & UX

1. [+] 增加了 PLS 下载操作的取消功能
2. [/] 修复了 FS IPC 中 `downloadFile` 时, 过早地从 downloadTasks 中删除任务的逻辑错误。
3. [↑] 改进了 PLS IPC 中 `handlePLSDownload` 获取版本信息时的逻辑, 现在该函数会从全局 API 信息中逐个尝试 API 域名。减少了极端网络环境下, 版本信息获取失败的可能性。
4. [/] 修复了下载失败后, 下载按钮依然保持灰显的问题。
5. [+] 为 PLS 下载增加了进度条显示。
6. [/] 优化了 `plsConnectionManager` 中一些不必要的 IPC 状态同步 (有些时候还会导致逻辑错误)。

.github/workflows/pack.yml

@@ -0,0 +1,136 @@
+name: Patch ASAR & Pack source code
+
+on:
+  push:
+    branches: [dev, stable]
+  pull_request:
+    branches: [dev, stable, main, master]
+  workflow_dispatch:
+
+jobs:
+  pack:
+    name: Patch & Pack
+
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Setup Node.JS 20 LTS
+        uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+
+      - name: Install dependencies
+        run: |
+          sudo apt update
+          sudo apt install -y p7zip-full wget
+          npm install -g asar
+
+      - name: Checkout repository code
+        uses: actions/checkout@v4
+        with:
+          path: "./HugoAura-Code"
+
+      - name: Download SeewoServiceSetup
+        run: |
+          echo "[DEBUG] Working DIR:"
+          pwd
+
+          wget -nv -O "SeewoService.exe" "https://e.seewo.com/download/file?code=SeewoServiceSetup"
+          echo "[DEBUG] Listing downloaded file"
+          ls -la SeewoService*
+
+      - name: Extract SeewoServiceSetup as zip
+        run: |
+          mkdir -p SeewoServiceSource
+          7z x "SeewoService.exe" -o"./SeewoServiceSource/" -y
+
+          echo "[DEBUG] Listing extracted files"
+          ls -la SeewoServiceSource/
+
+      - name: Extract ASAR file
+        run: |
+          cd SeewoServiceSource
+          SEEWO_DIR=$(find . -name "SeewoService_*" -type d | head -1)
+          echo "[INFO] Found SeewoService directory: $SEEWO_DIR"
+
+          cd "$SEEWO_DIR/SeewoServiceAssistant/resources/"
+
+          asar extract ./app.asar ./app-unpacked
+
+      - name: Move app-unpacked and clean SSASource
+        run: |
+          mkdir -p SSARes
+
+          cd SeewoServiceSource
+          SEEWO_DIR=$(find . -name "SeewoService_*" -type d | head -1)
+          mv "$SEEWO_DIR/SeewoServiceAssistant/resources/app-unpacked" "../SSARes/"
+
+          cd ..
+          rm -rf SeewoServiceSource
+          rm -rf *.exe
+          echo "[DEBUG] Listing Working DIR"
+          ls -la
+
+      - name: Patch main.js
+        run: |
+          cd SSARes/app-unpacked
+
+          ### cp main.js main.js.bak
+
+          cat > patch_main.js << 'EOF'
+          const fs = require('fs');
+
+          let content = fs.readFileSync('main.js', 'utf8');
+
+          content = 'const hook = require("./hook.js");\n' + content;
+
+          content = content.replace(/n\.m=e/, ';const zeron = require("./zeron.js");n = zeron(n);n.m=e');
+
+          content = content.replace(/let f=new s\(Object\.assign\(\{\},\{transparent:!0,/, ';hook({ central: n, windowName: this.wname, config: c });let f=new s(Object.assign({},{transparent:!0,');
+
+          content = content.replace(/c\.canOpenDevTool/, 'c.canOpenDevTool,preload: __dirname + "\\\\preload.js"');
+
+          fs.writeFileSync('main.js', content);
+
+          console.log('[SUCCESS] main.js has been modified successfully');
+          EOF
+
+          echo "[DEBUG] Running patch_main.js"
+          node ./patch_main.js
+
+          rm -rf patch_main.js
+
+      - name: Copy HugoAura core files
+        run: |
+          cp -r HugoAura-Code/src/core/* SSARes/app-unpacked/
+
+          echo "[DEBUG] Listing files under <Working DIR>/SSARes/app-unpacked/"
+          ls -la SSARes/app-unpacked/
+
+      - name: Create artifacts DIR and re-pack ASAR
+        run: |
+          echo "[DEBUG] Creating artifacts directory"
+          mkdir -p Artifacts
+
+          asar pack SSARes/app-unpacked Artifacts/app-patched.asar
+
+      - name: Create aura.zip
+        run: |
+          cd HugoAura-Code/src/aura
+          zip -r ../../../Artifacts/aura.zip .
+          cd ../../..
+
+          echo "[DEBUG] Files in <Working DIR>/Artifacts directory:"
+          ls -la Artifacts/
+
+      - name: Upload patched ASAR
+        uses: actions/upload-artifact@v4
+        with:
+          name: asar-patched
+          path: Artifacts/app-patched.asar
+
+      - name: Upload aura.zip
+        uses: actions/upload-artifact@v4
+        with:
+          name: aura-code
+          path: Artifacts/aura.zip

.gitignore

@@ -1,29 +1,24 @@
-# Dependencies
-
-node_modules/
-.npm
-.yarn
-
-# ESLint Cache
-
-.eslintcache
-
-# NYC Test Output
-
-.nyc_output
-
-# Build Artifacts
-
-/dist
-/buikd
-
-# dotEnv Files
-
-.env
-.env*
-
-# Misc
-
-.DS_Store
-*.log
-*.bak
+# SSA Defaults
+
+_extraResources
+addons/
+app.asar/addons
+app.asar/assets
+app.asar/config
+app.asar/node_modules
+app.asar/public
+app.asar/main.js
+app.asar/package.json
+assets/
+
+autoConfiguration.json
+
+# NPM Packages
+node_modules/
+
+# OS Files
+desktop.ini
+.DS_Store
+
+# Editor Files
+.vscode/

README.md

@@ -1,20 +1,20 @@
 <center><img src="https://s2.loli.net/2025/04/18/IpZL7qMw2KFEi8o.png" /></center>
 
-
 <h1 align="center">HugoAura</h1>
 <h4 align="center">下一代希沃管家注入式修改方案</h4>
 <div align="center">
   <a href="https://github.com/HugoAura/HugoAura">首页</a> · <a href="https://hugoaura.org/about">关于</a> · <a href="https://github.com/HugoAura/HugoAura/wiki">文档</a> · <a href="https://github.com/HugoAura/HugoAura/issues">反馈</a>
 </div>
 
-
 <br />
 
 > [!TIP]
 > HugoAura 的首个预览版已发布! [查看安装教程](https://github.com/HugoAura/HugoAura/wiki)
 
 > [!IMPORTANT]
-> 已经过测试的希沃管家版本: v1.5.4.3822
+> 已经过测试的希沃管家版本: v1.5.4.3824
+
+![Repobeats](https://repobeats.axiom.co/api/embed/69b5be5daacef624b8f5e4b8966a0b5898439a22.svg "Repobeats analytics image")
 
 ## ✨ 概览
 
@@ -32,8 +32,8 @@
 
 - [x] 修改希沃管家密码认证组件 (自定义密码 / 解除密码 / 重设认证方式 / ...)
 - [x] 阻止希沃管家前端 Audit 上报行为
+- [x] 屏蔽屏幕锁 / 自定义屏幕锁行为
 - [ ] Aura 代理层服务 (篡改上报数据 / 欺骗冰冻状态)
-- [ ] 屏蔽屏幕锁 / 自定义屏幕锁行为
 - [ ] 窥屏提醒
 - [ ] 插件功能
 

jsconfig.json

@@ -6,4 +6,4 @@
     "strictNullChecks": true,
     "strictFunctionTypes": true
   }
-}
+}

package.json

@@ -1,6 +1,6 @@
 {
   "name": "HugoAura",
-  "version": "0.1.1-pre-II",
+  "version": "0.1.1-pre-IV",
   "description": "Aura for SeewoHugo",
   "main": "app.asar/main.js",
   "dependencies": {},

src/aura/init/main/ipcHandler.js

@@ -11,7 +11,7 @@ const buildIpcMain = (electron) => {
   /**
    * @type {import("../../types/main/electron").AuraIPCMain}
    */
-  // @ts-ignore
+  // @ts-expect-error
   const ipcMain = electron.ipcMain;
 
   /**
@@ -28,11 +28,33 @@ const buildIpcMain = (electron) => {
      * @param {string} chan
      * @param {any} targetData
      */
+    if (!global.__HUGO_AURA__.hookedWindows) {
+      return {
+        success: false,
+      };
+    }
+
     const sendDataToWebContents = (key, chan, targetData) => {
       const webContents =
-        global.__HUGO_AURA__.hookedWindows.get(key).webContents;
+        // @ts-expect-error
+        global.__HUGO_AURA__.hookedWindows.get(key)?.webContents;
 
-      if (grep !== webContents) webContents.send(chan, targetData);
+      if (!webContents) {
+        console.error(
+          `[HugoAura / Main / IPC / ERROR] Failed sending data to ${key}: WebContents not found`
+        );
+        return {
+          success: false,
+        };
+      }
+
+      if (grep !== webContents) {
+        webContents.send(chan, targetData);
+      }
+
+      return {
+        success: true,
+      };
     };
 
     if (windowKey === "*") {
@@ -42,15 +64,20 @@ const buildIpcMain = (electron) => {
     } else {
       const isWindowValid = global.__HUGO_AURA__.hookedWindows.has(windowKey);
       if (!isWindowValid) {
-        throw new Error(
-          `[HugoAura / Main / IPC / ERROR] Unknown windowKey: ${windowKey}`
+        console.warn(
+          `[HugoAura / Main / IPC / WARN] Unknown windowKey: ${windowKey}, window may not have started yet.`
         );
+        return {
+          success: false,
+        };
       }
 
       sendDataToWebContents(windowKey, channel, data);
     }
   };
 
+  const { applyConfigIpcHandler } = require("./ipcModules/configIpcHandler");
+  const { applyFsIpcHandler } = require("./ipcModules/fsIpcHandler");
   const { applyPlsIpcHandler } = require("./ipcModules/plsIpcHandler");
 
   ipcMain.handle("$aura.base.restartApplication", async () => {
@@ -58,6 +85,8 @@ const buildIpcMain = (electron) => {
     app.exit(0);
   });
 
+  applyConfigIpcHandler(ipcMain);
+  applyFsIpcHandler(ipcMain);
   applyPlsIpcHandler(ipcMain);
 };
 

src/aura/init/main/ipcModules/configIpcHandler.js

@@ -0,0 +1,79 @@
+// @ts-check
+
+const __SCOPE = "main";
+
+/**
+ *
+ * @param {import("../../../types/main/electron").AuraIPCMain} ipcMain
+ */
+const applyConfigIpcHandler = (ipcMain) => {
+  const methodBase = "$aura.config";
+
+  const mainEventBus = global.__HUGO_AURA_EVENT_BUS__;
+
+  const ConfigManager = require("../../shared/configManager");
+  const configManager = global.__HUGO_AURA_CONFIG_MGR__
+    ? global.__HUGO_AURA_CONFIG_MGR__
+    : new ConfigManager();
+
+  ipcMain.on(`${methodBase}.refreshMainConfig`, (_event) => {
+    mainEventBus.emit("$aura.config.refreshConfig");
+  });
+
+  ipcMain.handle(
+    `${methodBase}.setConfigEncSettings`,
+    (
+      /** @type {import("electron").IpcMainInvokeEvent} */ _event,
+      /** @type {{ target: boolean }} */ arg
+    ) => {
+      mainEventBus.emit("$aura.config.updateConfigEncSettings", arg.target);
+      return {
+        success: true,
+      };
+    }
+  );
+
+  ipcMain.on(`${methodBase}.getConfigFromMainSync`, (event, _arg) => {
+    if (
+      global.__HUGO_AURA_CONFIG__ &&
+      Object.keys(global.__HUGO_AURA_CONFIG__).length !== 0
+    ) {
+      event.returnValue = {
+        success: true,
+        data: global.__HUGO_AURA_CONFIG__,
+      };
+    } else {
+      console.warn(
+        "[HugoAura / Main / IPC / Config / WARN] Global config var not found!"
+      );
+      event.returnValue = {
+        success: false,
+        data: {},
+      };
+    }
+  });
+
+  ipcMain.handle(
+    `${methodBase}.dispatchConfigFromRenderer`,
+    (_event, /** @type {{data: string, writeConfig?: boolean}} */ arg) => {
+      const parsedData = JSON.parse(arg.data);
+
+      global.__HUGO_AURA_CONFIG__ = parsedData;
+
+      if (arg.writeConfig) {
+        const result = configManager.writeConfig(parsedData);
+        if (!result) {
+          return {
+            success: false,
+          };
+        }
+      }
+
+      return {
+        success: true,
+      };
+    }
+  );
+};
+
+module.exports = { applyConfigIpcHandler };

src/aura/init/main/ipcModules/fsIpcHandler.js

@@ -0,0 +1,207 @@
+// @ts-check
+
+const __SCOPE = "main";
+
+const { exec } = require("child_process");
+const nodeHttp = require("http");
+const nodeHttps = require("https");
+const fs = require("fs");
+const path = require("path");
+
+const { genRandomHex } = require("../../../utils/crypto");
+
+const composableFunctions = {
+  /**
+   *
+   * @param {string} url
+   * @param {string} targetPath
+   * @param {((arg: DownloadTask) => any)} progressCallback
+   */
+  downloadFile: async (url, targetPath, progressCallback) => {
+    if (!progressCallback) return false;
+    const taskId = genRandomHex();
+
+    /**
+     * @type {DownloadTask}
+     */
+    const failedTemplate = {
+      id: taskId,
+      progress: 100,
+      status: "failed",
+      dlUrl: url,
+      savePath: targetPath,
+      message: "",
+    };
+
+    if (!url || !targetPath) {
+      failedTemplate.message = "Invalid arg";
+      progressCallback(failedTemplate);
+      return false;
+    }
+
+    const dirName = path.dirname(targetPath);
+
+    if (!fs.existsSync(dirName)) {
+      fs.mkdirSync(dirName);
+    }
+
+    const httpModuleIns = url.startsWith("https") ? nodeHttps : nodeHttp;
+
+    global.__HUGO_AURA__.fsTasks?.downloadTasks.set(taskId, {
+      status: "waiting",
+      cancelReq: null,
+    });
+
+    progressCallback({
+      id: taskId,
+      progress: 0,
+      status: "waiting",
+      dlUrl: url,
+      savePath: targetPath,
+    });
+
+    const fsStream = fs.createWriteStream(targetPath);
+
+    const dlReq = httpModuleIns.get(url, (response) => {
+      if (response.statusCode !== 200) {
+        fsStream.close();
+        failedTemplate.message = `Request error: HTTP ${response.statusCode}`;
+        progressCallback(failedTemplate);
+        return false;
+      }
+
+      const contentLength = response.headers["content-length"];
+      // @ts-expect-error
+      const totalBytes = parseInt(contentLength, 10) || 0; // No error handling 😆
+      let curRecvBytes = 0;
+
+      let hasCancelled = false;
+
+      global.__HUGO_AURA__.fsTasks?.downloadTasks.set(taskId, {
+        status: "progressing",
+        cancelReq: () => {
+          hasCancelled = true;
+          dlReq.destroy();
+          fsStream.close();
+          fs.unlink(targetPath, () => {});
+          global.__HUGO_AURA__.fsTasks?.downloadTasks.delete(taskId);
+          progressCallback({
+            id: taskId,
+            progress: 100,
+            curBytes: curRecvBytes,
+            totalBytes: totalBytes,
+            status: "cancelled",
+            dlUrl: url,
+            savePath: targetPath,
+          });
+        },
+      });
+
+      response.on("data", (chunk) => {
+        curRecvBytes += chunk.length;
+        const curProgress =
+          totalBytes > 0 ? (curRecvBytes / totalBytes) * 100 : 0;
+        progressCallback({
+          id: taskId,
+          progress: curProgress.toFixed(2),
+          curBytes: curRecvBytes,
+          totalBytes: totalBytes,
+          status: "progressing",
+          dlUrl: url,
+          savePath: targetPath,
+        });
+      });
+
+      response.pipe(fsStream);
+
+      fsStream.on("finish", () => {
+        fsStream.close();
+        if (hasCancelled) {
+          return;
+        }
+        progressCallback({
+          id: taskId,
+          progress: (100).toFixed(2),
+          curBytes: curRecvBytes,
+          totalBytes: totalBytes,
+          status: "done",
+          dlUrl: url,
+          savePath: targetPath,
+        });
+        global.__HUGO_AURA__.fsTasks?.downloadTasks.delete(taskId);
+      });
+
+      return true;
+    });
+
+    dlReq.on("error", (e) => {
+      fsStream.close();
+      fs.unlink(targetPath, () => {});
+      failedTemplate.message =
+        "Request error: Unexpected error while downloading file";
+      failedTemplate.errorObj = e;
+      console.error(
+        `[HugoAura / IPC / FS / ERROR] Error downloading file from ${url}, errorObj:`,
+        e
+      );
+      progressCallback(failedTemplate);
+      global.__HUGO_AURA__.fsTasks?.downloadTasks.delete(taskId);
+      return false;
+    });
+  },
+};
+
+/**
+ *
+ * @param {import("electron").IpcMain} ipcMain
+ */
+const applyFsIpcHandler = (ipcMain) => {
+  const methodBase = "$aura.fs";
+
+  global.__HUGO_AURA__.fsTasks = {
+    downloadTasks: new Map(),
+  };
+
+  ipcMain.handle(
+    `${methodBase}.dl.cancelDownloadTask`,
+    /**
+     *
+     * @param {import("electron").IpcMainInvokeEvent} _evt
+     * @param {{ targetTaskId: string }} arg
+     * @returns {{ success: boolean, error: string | null }}
+     */
+    (_evt, arg) => {
+      if (!arg.targetTaskId) {
+        return {
+          success: false,
+          error: "ARG_INVALID",
+        };
+      }
+
+      if (!global.__HUGO_AURA__.fsTasks?.downloadTasks.has(arg.targetTaskId)) {
+        return {
+          success: false,
+          error: "TASK_ID_NOT_FOUND",
+        };
+      }
+
+      const taskObj = global.__HUGO_AURA__.fsTasks.downloadTasks.get(
+        arg.targetTaskId
+      );
+      if (!taskObj?.cancelReq) {
+        return {
+          success: false,
+          error: "TASK_NOT_STARTED",
+        };
+      }
+
+      taskObj.cancelReq();
+      return {
+        success: true,
+        error: null,
+      };
+    }
+  );
+};
+
+module.exports = { fsComposables: composableFunctions, applyFsIpcHandler };

src/aura/init/main/ipcModules/plsIpcHandler.js

@@ -2,8 +2,212 @@
 
 const __SCOPE = "main";
 
+const { exec } = require("child_process");
 const fs = require("fs");
 const path = require("path");
+const nodeHttps = require("https");
+const { fsComposables } = require("./fsIpcHandler");
+
+const functions = {
+  querySvcDetail: (
+    /** @type {string} */ svcName,
+    /** @type {string} */ findTarget
+  ) => {
+    return new Promise((resolve) => {
+      exec(
+        `sc query ${svcName}`,
+        { encoding: "utf8" },
+        (error, stdout, stderr) => {
+          if (error) {
+            resolve({
+              success: true,
+              result: false,
+            });
+            return;
+          }
+          if (stdout.includes(findTarget)) {
+            resolve({
+              success: true,
+              result: true,
+            });
+          } else {
+            resolve({
+              success: true,
+              result: false,
+            });
+          }
+        }
+      );
+    });
+  },
+
+  /**
+   *
+   * @param {string} logHeader
+   * @param {string} binPath
+   * @param {string} command
+   * @returns {Promise<{ success: boolean, errorObj?: Error }>}
+   */
+  execCommand: (logHeader, binPath, command) => {
+    const processedPath = binPath.includes(" ") ? `"${binPath}"` : binPath;
+    return new Promise((resolve) => {
+      exec(`${processedPath} ${command}`, (error, stdout, stderr) => {
+        if (error) {
+          console.error(`${logHeader} Failed to execute command:`, error);
+          resolve({ success: false, errorObj: error });
+          return;
+        }
+        resolve({ success: true });
+      });
+    });
+  },
+
+  /**
+   *
+   * @param {"stable" | "alpha"} channel
+   * @param {(arg: DownloadTask) => any} callbackFn
+   * @param {string} binPath
+   */
+  handlePLSDownload: async (channel, callbackFn, binPath) => {
+    // TODO: Channel selection
+    const apiInfo = global.__HUGO_AURA_API__;
+
+    const getVerPromise = new Promise(async (resolveGetVerReq) => {
+      // ↓ 目前 channel param 没有什么用处
+      for (const apiDomain of apiInfo.domains) {
+        const reqPromise = new Promise((resolveHttpRequest) => {
+          nodeHttps
+            .get(
+              `${apiDomain}${apiInfo.plsUpdate}?channel=${channel}`,
+              (rep) => {
+                let dataChunk = "";
+                rep.on("data", (chunk) => {
+                  dataChunk += chunk;
+                });
+
+                rep.on("end", () => {
+                  let parsedData = {};
+                  try {
+                    parsedData = JSON.parse(dataChunk);
+                  } catch (e) {
+                    callbackFn({
+                      id: "",
+                      progress: 0,
+                      status: "struggling",
+                      dlUrl: null,
+                      savePath: null,
+                      message: `数据解析失败, 正在尝试 API 域名 ${
+                        apiInfo.domains[apiInfo.domains.indexOf(apiDomain) + 1]
+                      } ...`,
+                      errorObj: e,
+                    });
+
+                    setTimeout(() => {
+                      resolveHttpRequest({
+                        success: false,
+                        errorObj: e,
+                      });
+                    }, 1000);
+                    return;
+                  }
+
+                  resolveHttpRequest({
+                    success: true,
+                    data: parsedData,
+                  });
+                  return;
+                });
+              }
+            )
+            .on("error", (e) => {
+              callbackFn({
+                id: "",
+                progress: 0,
+                status: "struggling",
+                dlUrl: null,
+                savePath: null,
+                message: `连接失败, 正在尝试 API 域名 ${
+                  apiInfo.domains[apiInfo.domains.indexOf(apiDomain) + 1]
+                } ...`,
+                errorObj: e,
+              });
+
+              setTimeout(() => {
+                resolveHttpRequest({
+                  success: false,
+                  errorObj: e,
+                });
+              }, 1000);
+            });
+        });
+
+        const requestResult = await reqPromise;
+        if (requestResult.success) {
+          resolveGetVerReq({
+            success: true,
+            data: requestResult.data,
+          });
+          break;
+        } else {
+          continue;
+        }
+      }
+
+      resolveGetVerReq({
+        success: false,
+        data: null,
+      });
+    });
+
+    const rawResInfo = await getVerPromise;
+    if (!rawResInfo.success) {
+      callbackFn({
+        id: "",
+        progress: 0,
+        status: "failed",
+        dlUrl: null,
+        savePath: null,
+        message: "未能获取 PLS 版本信息, 所有 API 域名均无法连接",
+      });
+      return false;
+    }
+
+    const plsVersionInfo = rawResInfo.data;
+
+    let deviceArch = process.env.PROCESSOR_ARCHITEW6432
+      ? process.env.PROCESSOR_ARCHITEW6432
+      : process.env.PROCESSOR_ARCHITECTURE;
+    // @ts-expect-error
+    deviceArch = deviceArch.toLowerCase();
+
+    if (!Object.keys(plsVersionInfo.data.downloadUrl).includes(deviceArch)) {
+      callbackFn({
+        id: "",
+        progress: 0,
+        status: "failed",
+        dlUrl: null,
+        savePath: null,
+        message: `处理器架构识别失败, 检测到的架构: ${deviceArch}`,
+      });
+      return false;
+    }
+
+    fsComposables.downloadFile(
+      plsVersionInfo.data.downloadUrl[deviceArch],
+      binPath,
+      (...args) => {
+        if (args[0].status === "done") {
+          if (global.__HUGO_AURA__.plsStats) {
+            global.__HUGO_AURA__.plsStats.installed = true;
+            global.__HUGO_AURA__.plsStats.status = "dead";
+          }
+        }
+
+        callbackFn(...args);
+      }
+    );
+  },
+};
 
 /**
  *
@@ -12,6 +216,10 @@ const path = require("path");
 const applyPlsIpcHandler = (ipcMain) => {
   const methodBase = "$aura.pls";
 
+  const PLS_INSTALL_DIR = path.join("C:\\Program Files", "HugoAura PLS", "bin");
+  const PLS_BIN_PATH = path.join(PLS_INSTALL_DIR, "HugoAura-PLS.exe");
+  const PLS_SVC_NAME = "HugoAuraPLS";
+
   const isPlsDetached = process.argv.includes("--pls-detach");
 
   global.__HUGO_AURA__.plsStats = {
@@ -25,20 +233,26 @@ const applyPlsIpcHandler = (ipcMain) => {
   };
 
   ipcMain.handle(
-    `${methodBase}.getPlsFolderExists`,
+    `${methodBase}.getPlsBinExists`,
     /**
      *
      * @returns {{ success: boolean; data: { isExists: boolean }; error?: Error }}
      */
     (_event, _arg) => {
-      const plsFolderPath = path.join(__dirname, "../../../proxy");
       try {
-        const result = fs.existsSync(plsFolderPath);
+        const result = fs.existsSync(PLS_BIN_PATH);
+
+        if (global.__HUGO_AURA__.plsStats?.status === "notInstalled") {
+          global.__HUGO_AURA__.plsStats.status = "dead";
+        }
+
         return {
           success: true,
           data: { isExists: result },
         };
       } catch (e) {
+        // @ts-expect-error
+        global.__HUGO_AURA__.plsStats.status = "notInstalled";
         return {
           success: false,
           data: { isExists: false },
@@ -48,11 +262,53 @@ const applyPlsIpcHandler = (ipcMain) => {
     }
   );
 
+  ipcMain.handle(
+    `${methodBase}.ensurePlsInstallDir`,
+    /**
+     *
+     * @param {import("electron").IpcMainInvokeEvent} _event
+     * @param {any} _arg
+     * @returns {{ success: boolean; data: { alreadyExists: boolean; createdDir: string; }; error?: Error }}
+     */
+    (_event, _arg) => {
+      const alreadyExists = fs.existsSync(PLS_INSTALL_DIR);
+      if (alreadyExists) {
+        return {
+          success: true,
+          data: {
+            alreadyExists: true,
+            createdDir: PLS_INSTALL_DIR,
+          },
+        };
+      }
+
+      try {
+        fs.mkdirSync(PLS_INSTALL_DIR);
+        return {
+          success: true,
+          data: {
+            alreadyExists: false,
+            createdDir: PLS_INSTALL_DIR,
+          },
+        };
+      } catch (error) {
+        return {
+          success: false,
+          data: {
+            alreadyExists: false,
+            createdDir: PLS_INSTALL_DIR,
+          },
+          error: error,
+        };
+      }
+    }
+  );
+
   ipcMain.handle(
     `${methodBase}.getPlsStats`,
     /**
      *
-     * @returns {{ success: boolean; data: PLSStatus; }}
+     * @returns {{ success: boolean; data: import("../../../types/shared/pls/status").PLSStatus | null | undefined; }}
      */
     (_event, _arg) => {
       return {
@@ -67,7 +323,7 @@ const applyPlsIpcHandler = (ipcMain) => {
     /**
      *
      * @param {import("electron").IpcMainInvokeEvent} _event
-     * @param {PLSStatus} arg
+     * @param {import("../../../types/shared/pls/status").PLSStatus} arg
      * @returns
      */
     (_event, arg) => {
@@ -83,7 +339,7 @@ const applyPlsIpcHandler = (ipcMain) => {
     `${methodBase}.getPlsSettings`,
     /**
      *
-     * @returns {{ success: boolean; data: Record<any, any> }}
+     * @returns {{ success: boolean; data: Record<any, any> | null | undefined }}
      */
     (_event, _arg) => {
       return {
@@ -103,6 +359,7 @@ const applyPlsIpcHandler = (ipcMain) => {
      */
     (_event, arg) => {
       global.__HUGO_AURA__.plsSettings = arg;
+      ipcMain.send("assistant", `${methodBase}.post.onPlsSettingsUpdate`, arg);
       return {
         success: true,
       };
@@ -113,7 +370,7 @@ const applyPlsIpcHandler = (ipcMain) => {
     `${methodBase}.getPlsRules`,
     /**
      *
-     * @returns {{ success: boolean; data: Record<any, any> }}
+     * @returns {{ success: boolean; data: Record<any, any> | null | undefined }}
      */
     (_event, _arg) => {
       return {
@@ -133,6 +390,7 @@ const applyPlsIpcHandler = (ipcMain) => {
      */
     (_event, arg) => {
       global.__HUGO_AURA__.plsRules = arg;
+      ipcMain.send("assistant", `${methodBase}.post.onPlsRulesUpdate`, arg);
       return {
         success: true,
       };
@@ -185,6 +443,157 @@ const applyPlsIpcHandler = (ipcMain) => {
       };
     }
   );
+
+  ipcMain.handle(
+    `${methodBase}.plsLifecycleQuery`,
+    /**
+     *
+     * @param {import("electron").IpcMainInvokeEvent} _event
+     * @param {{ target: import("../../../types/shared/pls/status").PLSLifecycleType }} arg
+     * @returns {Promise<{ success: boolean, result: boolean }>}
+     */
+    async (_event, arg) => {
+      switch (arg.target) {
+        case "isDetached":
+          return { success: true, result: isPlsDetached };
+        case "isSvcInstalled":
+          return await functions.querySvcDetail(PLS_SVC_NAME, "SERVICE_NAME");
+        case "isSvcStart":
+          return await functions.querySvcDetail(PLS_SVC_NAME, "RUNNING");
+        default:
+          console.warn(
+            `[HugoAura / IPC / PLS] <plsLifecycleQuery> Invalid arg.target: ${arg.target}`
+          );
+          return {
+            success: false,
+            result: false,
+          };
+      }
+    }
+  );
+
+  ipcMain.handle(
+    `${methodBase}.plsLifecycleControl`,
+    /**
+     *
+     * @param {*} _event
+     * @param {{ target: import("../../../types/shared/pls/status").PLSLifecycleControlType }} arg
+     * @returns {Promise<{ success: boolean, errorObj?: Error }>}
+     */
+    async (_event, arg) => {
+      const logHeader = "[HugoAura / IPC / PLS] <plsLifecycleControl>";
+
+      switch (arg.target) {
+        case "instSvc":
+          return await functions.execCommand(
+            logHeader,
+            PLS_BIN_PATH,
+            "--startup auto install"
+          );
+        case "rmSvc":
+          return await functions.execCommand(logHeader, PLS_BIN_PATH, "remove");
+        case "startSvc":
+          return await functions.execCommand(logHeader, PLS_BIN_PATH, "start");
+        case "stopSvc":
+          return await functions.execCommand(logHeader, PLS_BIN_PATH, "stop");
+        case "rmBin":
+          const unlinkPromise = new Promise((resolve) => {
+            fs.unlink(PLS_BIN_PATH, (error) => {
+              if (error) {
+                resolve({
+                  success: false,
+                  errorObj: error,
+                });
+                console.error(
+                  `${logHeader} Failed to remove PLS bin, error:`,
+                  error
+                );
+                return false;
+              }
+
+              resolve({
+                success: true,
+                errorObj: null,
+              });
+              return true;
+            });
+          });
+
+          const unlinkRet = await unlinkPromise;
+
+          return unlinkRet;
+        default:
+          return { success: false, errorObj: new Error("Method not found") };
+      }
+    }
+  );
+
+  ipcMain.handle(
+    `${methodBase}.downloadPls`,
+    /**
+     *
+     * @param {import("electron").IpcMainInvokeEvent} _evt
+     * @param {{channel?: "stable" | "alpha", reportTo?: import("../../../types/main/core").WindowName}} arg
+     * @returns {void}
+     */
+    (_evt, arg) => {
+      const channel = arg.channel ? arg.channel : "stable";
+      const reportWin = arg.reportTo ? arg.reportTo : "assistant";
+      functions.handlePLSDownload(
+        channel,
+        (status) => {
+          ipcMain.send(
+            reportWin,
+            `${methodBase}.post.reportPlsDownloadStatus`,
+            status
+          );
+        },
+        PLS_BIN_PATH
+      );
+    }
+  );
+
+  ipcMain.handle(
+    `${methodBase}.retryPlsConnect`,
+    /**
+     *
+     * @param {import("electron").IpcMainInvokeEvent} _event
+     * @param {any} arg
+     * @returns {{ success: boolean, status: "Already" | "Retrying" }}
+     */
+    (_event, arg) => {
+      if (global.__HUGO_AURA__.plsStats?.connected) {
+        return {
+          success: true,
+          status: "Already",
+        };
+      } else {
+        ipcMain.send("desktopAssistant", `${methodBase}.retryPlsConnect`, arg);
+
+        return {
+          success: true,
+          status: "Retrying",
+        };
+      }
+    }
+  );
+
+  ipcMain.handle(
+    `${methodBase}.post.updateRetryStatus`,
+
+    /**
+     *
+     * @param {import("electron").IpcMainInvokeEvent} _event
+     * @param {{ success: boolean }} arg
+     */
+    (_event, arg) => {
+      ipcMain.send("assistant", `${methodBase}.post.updateRetryStatus`, arg);
+
+      return {
+        success: true,
+      };
+    }
+  );
 };
 
 module.exports = { applyPlsIpcHandler };

src/aura/init/main/logger.js

@@ -0,0 +1,111 @@
+const path = require("path");
+const fs = require("fs");
+const os = require("os");
+const util = require("util");
+
+/**
+ *
+ * @param {import("../aura/types/main/core").WindowName} windowName
+ */
+const initLogger = (windowName) => {
+  const logDir = path.join(os.homedir(), "Documents", "HugoAura", "logs");
+  if (!fs.existsSync(logDir)) {
+    fs.mkdirSync(logDir, { recursive: true });
+  }
+
+  cleanupOldLogs(logDir);
+  const logFile = getLogFileName(logDir);
+  const logStream = fs.createWriteStream(logFile, { flags: "a" });
+
+  const timestamp = new Date().toISOString();
+  const startupMsg = `\n=== [${timestamp}] HugoAura 窗口启动: ${windowName} ===\n\n`;
+  logStream.write(startupMsg);
+
+  const originalConsole = {
+    log: console.log,
+    error: console.error,
+    warn: console.warn,
+    info: console.info,
+    debug: console.debug,
+  };
+
+  console.log = function (...args) {
+    const msg = util.format(`[LOG] <${windowName}>`, ...args) + "\n";
+    logStream.write(msg);
+    originalConsole.log.apply(console, args);
+  };
+
+  console.error = function (...args) {
+    const msg = util.format(`[ERROR] <${windowName}>`, ...args) + "\n";
+    logStream.write(msg);
+    originalConsole.error.apply(console, args);
+  };
+
+  console.warn = function (...args) {
+    const msg = util.format(`[WARN] <${windowName}>`, ...args) + "\n";
+    logStream.write(msg);
+    originalConsole.warn.apply(console, args);
+  };
+
+  console.info = function (...args) {
+    const msg = util.format(`[INFO] <${windowName}>`, ...args) + "\n";
+    logStream.write(msg);
+    originalConsole.info.apply(console, args);
+  };
+
+  console.debug = function (...args) {
+    if (!process.argv.includes("--aura-debug")) return;
+    const msg = util.format(`[DEBUG] <${windowName}>`, ...args) + "\n";
+    logStream.write(msg);
+    originalConsole.debug.apply(console, args);
+  };
+
+  process.on("uncaughtException", (err) => {
+    console.error("[CRITICAL] UNCAUGHT EXCEPTION:", err);
+  });
+
+  console.log(
+    "[HugoAura / Logger] Logger initialized. Log file:",
+    logFile
+  );
+};
+
+const cleanupOldLogs = (logDir) => {
+  try {
+    const files = fs.readdirSync(logDir);
+    const now = new Date();
+    const sevenDaysAgo = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000);
+
+    files.forEach((file) => {
+      if (file.endsWith(".log")) {
+        const filePath = path.join(logDir, file);
+        const stats = fs.statSync(filePath);
+
+        // 如果文件创建时间超过 30 天, 则删除
+        if (stats.birthtime < sevenDaysAgo) {
+          fs.unlinkSync(filePath);
+          console.log(
+            `[HugoAura / Logger / Cleanup] Cleaned log file: ${file}`
+          );
+        }
+      }
+    });
+  } catch (error) {
+    console.error("[HugoAura / Logger / Cleanup] Unexpected error occurred cleaning log file:", error);
+  }
+};
+
+/**
+ * 生成每日 Log 文件路径
+ * @param {string} logDir 日志目录路径
+ * @param {string} _windowName 窗口名称 (暂时无用)
+ * @returns {string} 日志文件路径
+ */
+const getLogFileName = (logDir, _windowName) => {
+  const today = new Date();
+  const dateStr = today.toISOString().split("T")[0]; // YYYY-MM-DD 格式
+  const logFileName = `HugoAura-SSA-${dateStr}.log`;
+  return path.join(logDir, logFileName);
+};
+
+module.exports = { initLogger };

src/aura/init/preload/webpackHook.js

@@ -1,4 +1,4 @@
-const path = require('path');
+const path = require("path");
 
 class WebpackHook {
   #ruleCache = new Map();
@@ -19,7 +19,7 @@ class WebpackHook {
         if (!rule) {
           rule = require(path.join(
             __dirname,
-            '../../../aura/jsRewrite/',
+            "../../../aura/jsRewrite/",
             rulePath
           ));
           this.#ruleCache.set(rulePath, rule);
@@ -49,7 +49,7 @@ class WebpackHook {
 
   patchModules(modules, rewrites) {
     modules.forEach((mod, index) => {
-      if (typeof mod !== 'function') return;
+      if (typeof mod !== "function") return;
       const stringifyFunc = mod.toString();
 
       rewrites.forEach((rewrite) => {
@@ -67,14 +67,14 @@ class WebpackHook {
             let rewrittenFunction = mod;
 
             switch (method) {
-              case 'reactComponent':
+              case "reactComponent":
                 window.__HUGO_AURA_HOOK__[ruleId] = {
                   feature: rewrite.feature,
-                  newFunction: rewrite.newFunction
-                }
+                  newFunction: rewrite.newFunction,
+                };
                 rewrittenFunction = rewrite.preHook(mod);
                 break;
-              case 'legacy':
+              case "legacy":
               default:
                 rewrittenFunction = rewrite.newFunction;
                 break;
@@ -95,7 +95,7 @@ class WebpackHook {
       });
     });
 
-    if (typeof window !== 'undefined') {
+    if (typeof window !== "undefined") {
       window.__HUGO_AURA_DEBUG__ = {
         getRuleCache: () => Array.from(this.#ruleCache.keys()),
       };
@@ -105,7 +105,7 @@ class WebpackHook {
   installHook(window, config) {
     let realWebpackJsonp = window.webpackJsonp;
 
-    Object.defineProperty(window, 'webpackJsonp', {
+    Object.defineProperty(window, "webpackJsonp", {
       get: () => realWebpackJsonp,
       set: (value) => {
         console.log(
@@ -119,7 +119,7 @@ class WebpackHook {
             if (args[0] && Array.isArray(args[0][1])) {
               const [chunkIds, modules] = args[0];
               console.log(
-                `[HugoAura / AppHook] Intercepting chunk ${chunkIds.join(', ')}`
+                `[HugoAura / AppHook] Intercepting chunk ${chunkIds.join(", ")}`
               );
 
               const rewrites = this.loadRewriteRules(config);

src/aura/init/rendererHook/injection.js

@@ -24,40 +24,6 @@
     });
   };
 
-  const createStore = () => {
-    const store = {
-      router: "/",
-    };
-    const internal = {
-      get: (key) => store[key],
-      set: (key, value) => {
-        store[key] = value;
-        return true;
-      },
-    };
-
-    window.$store = {
-      get: (key) => {
-        const stack = new Error().stack;
-        if (stack.includes("aura/ui/pages/")) {
-          return internal.get(key);
-        }
-        return undefined;
-      },
-      set: (key, value) => {
-        const stack = new Error().stack;
-        if (stack.includes("aura/ui/pages/")) {
-          return internal.set(key, value);
-        }
-        return false;
-      },
-    };
-
-    return internal;
-  };
-
-  const store = createStore();
-
   const createUILoader = () => {
     const modules = "__TEMPLATE_TARGETS__";
     const containers = new Map();
@@ -65,6 +31,63 @@
     const moduleResources = new Map();
     const globalScripts = new Set();
 
+    const flattenTargets = (targets, parentKey = "") => {
+      const flattened = {};
+
+      for (const [key, config] of Object.entries(targets)) {
+        const fullKey = parentKey ? `${parentKey}.${key}` : key;
+        flattened[fullKey] = { ...config };
+
+        if (
+          config.childs &&
+          typeof config.childs === "object" &&
+          !Array.isArray(config.childs)
+        ) {
+          const childTargets = flattenTargets(config.childs, fullKey);
+          Object.assign(flattened, childTargets);
+          delete flattened[fullKey].childs;
+        }
+      }
+
+      return flattened;
+    };
+
+    const flatModules = flattenTargets(modules);
+
+    const createAccessProxy = (originalModules, flatModules) => {
+      const createNestedProxy = (target, path = []) => {
+        return new Proxy(target, {
+          get(target, prop) {
+            const currentPath = [...path, prop].join(".");
+
+            if (flatModules[currentPath]) {
+              return flatModules[currentPath];
+            }
+
+            const value = Reflect.get(target, prop);
+            if (typeof value === "object" && value !== null) {
+              return createNestedProxy(value, [...path, prop]);
+            }
+
+            return value;
+          },
+          set(target, prop, value) {
+            const currentPath = [...path, prop].join(".");
+
+            if (flatModules[currentPath]) {
+              flatModules[currentPath] = value;
+            }
+
+            return Reflect.set(target, prop, value);
+          },
+        });
+      };
+
+      return createNestedProxy(originalModules);
+    };
+
+    const accessibleModules = createAccessProxy(modules, flatModules);
+
     const insertElement = (target, element, mode = "appendChild") => {
       const elementId = element.id;
       if (document.getElementById(elementId)) {
@@ -120,12 +143,12 @@
       const observer = new MutationObserver((_mutations) => {
         if (!document.getElementById(elementId)) {
           let targetElement = document.querySelector(
-            modules[moduleKey].pageSelector
+            flatModules[moduleKey].pageSelector
           );
           if (
             targetElement &&
-            modules[moduleKey].active &&
-            modules[moduleKey].revive
+            flatModules[moduleKey].active &&
+            flatModules[moduleKey].revive
           ) {
             if (!document.getElementById(elementId)) {
               console.log(
@@ -145,12 +168,53 @@
       observers.set(moduleKey, observer);
     };
 
+    const loadResources = async (resources, type, moduleKey, isRevive) => {
+      if (!resources || isRevive) return [];
+
+      const resourceArray = Array.isArray(resources) ? resources : [resources];
+      const loadedResources = [];
+
+      for (const resource of resourceArray) {
+        try {
+          let element;
+          if (type === "css") {
+            element = document.createElement("link");
+            element.rel = "stylesheet";
+            element.href = `../../aura/${resource}`;
+            document.head.appendChild(element);
+          } else if (type === "js") {
+            element = document.createElement("script");
+            element.src = `../../aura/${resource}`;
+            document.body.appendChild(element);
+            await new Promise((resolve, reject) => {
+              element.onload = resolve;
+              element.onerror = reject;
+            });
+          }
+
+          if (element) {
+            loadedResources.push(element);
+            console.log(
+              `[HugoAura / UI / ${moduleKey}] Loaded ${type}: ${resource}`
+            );
+          }
+        } catch (err) {
+          console.error(
+            `[HugoAura / UI / Error] Failed to load ${type} ${resource} for ${moduleKey}:`,
+            err
+          );
+        }
+      }
+
+      return loadedResources;
+    };
+
     const loader = {
       async loadModule(moduleKey, isRevive = false) {
-        if (!modules[moduleKey]?.active) return;
+        if (!flatModules[moduleKey]?.active) return;
 
         try {
-          const config = modules[moduleKey];
+          const config = flatModules[moduleKey];
           const target = await waitForElement(config.pageSelector);
           const elementId = `aura-container-${moduleKey.replace(/\./g, "-")}`;
 
@@ -168,12 +232,14 @@
           const resources = new Set();
           moduleResources.set(moduleKey, resources);
 
-          if (config.pageCSS && !isRevive) {
-            const link = document.createElement("link");
-            link.rel = "stylesheet";
-            link.href = `../../aura/${config.pageCSS}`;
-            document.head.appendChild(link);
-            resources.add(link);
+          if (config.pageCSS) {
+            const cssResources = await loadResources(
+              config.pageCSS,
+              "css",
+              moduleKey,
+              isRevive
+            );
+            cssResources.forEach((resource) => resources.add(resource));
           }
 
           const html = await fetch(`../../aura/${config.pageURI}`).then((r) =>
@@ -184,18 +250,21 @@
           insertElement(target, container, config.selectorMode);
           monitorParent(moduleKey, target, container, config.selectorMode);
 
-          if (config.pageScript && !isRevive) {
-            const script = document.createElement("script");
-            script.src = `../../aura/${config.pageScript}`;
-            document.body.appendChild(script);
-            resources.add(script);
+          if (config.pageScript) {
+            const jsResources = await loadResources(
+              config.pageScript,
+              "js",
+              moduleKey,
+              isRevive
+            );
+            jsResources.forEach((resource) => resources.add(resource));
           }
 
           const observer = new MutationObserver(() => {
             if (
               !document.contains(container) &&
-              modules[moduleKey].active &&
-              modules[moduleKey].revive
+              flatModules[moduleKey].active &&
+              flatModules[moduleKey].revive
             ) {
               this.loadModule(moduleKey, true);
             }
@@ -238,13 +307,13 @@
 
       handleModuleChange(moduleKey, path = []) {
         const fullPath = [...path, moduleKey].join(".");
-        if (path.length === 0 && modules[moduleKey].active) {
+        if (path.length === 0 && flatModules[moduleKey].active) {
           this.loadModule(moduleKey);
         } else if (path.length === 0) {
           this.unloadModule(moduleKey);
         } else {
           if (moduleKey === "active") {
-            if (modules[path[0]].active) {
+            if (flatModules[path[0]].active) {
               this.loadModule(path[0]);
             } else {
               this.unloadModule(path[0]);
@@ -297,7 +366,7 @@
       try {
         await loadGlobalJS();
 
-        for (const [key, config] of Object.entries(modules)) {
+        for (const [key, config] of Object.entries(flatModules)) {
           if (config.active) {
             await loader.loadModule(key);
           }
@@ -309,7 +378,7 @@
 
     initialLoad();
 
-    return createDeepProxy(modules, (path, prop, value) => {
+    return createDeepProxy(accessibleModules, (path, prop, value) => {
       loader.handleModuleChange(prop, path);
     });
   };

src/aura/init/rendererHook/uiHooksManager.js

@@ -14,7 +14,7 @@ class RendererHooksManager {
 
     const hooksPath = path.join(__dirname, "../../../aura/ui/hookDefinitions");
 
-    /** @type {import("../../types/main/core").HooksMap} */
+    /** @type {import("../../types/main/core").UIHooksMap} */
     const hooks = new Map();
 
     try {
@@ -65,6 +65,7 @@ class RendererHooksManager {
       webContents.removeListener("destroyed", destroyedListener);
     }
 
+    // @ts-expect-error
     global.__HUGO_AURA__.hookedWindows.delete(windowKey);
   }
 
@@ -80,6 +81,7 @@ class RendererHooksManager {
 
     /** @type {import("../../types/main/core").WindowName} */
     const windowKey = `${hookConfig.windowName || windowName}`;
+    // @ts-expect-error
     if (global.__HUGO_AURA__.hookedWindows.has(windowKey)) {
       console.log(
         `[HugoAura / Init / RDH] Duplicate ui hook for ${windowKey}, ignoring...`
@@ -87,7 +89,9 @@ class RendererHooksManager {
       return;
     }
 
-    console.log(`[HugoAura / Init / RDH] UI Hook is initializing for ${windowKey}...`);
+    console.log(
+      `[HugoAura / Init / RDH] UI Hook is initializing for ${windowKey}...`
+    );
     console.log(
       `[HugoAura / Init / RDH] UI Hook loaded at: ${new Date().toISOString()}`
     );
@@ -135,6 +139,7 @@ class RendererHooksManager {
     const destroyedListener = () => {
       this.cleanupWindow(
         windowKey,
+        // @ts-expect-error
         global.__HUGO_AURA__.hookedWindows.get(windowKey)
       );
     };
@@ -142,6 +147,7 @@ class RendererHooksManager {
     webContents.on("dom-ready", domReadyListener);
     webContents.on("destroyed", destroyedListener);
 
+    // @ts-expect-error
     global.__HUGO_AURA__.hookedWindows.set(windowKey, {
       webContents,
       domReadyListener,

src/aura/init/shared/configManager.js

@@ -6,6 +6,9 @@ const os = require("os");
 const crypto = require("crypto");
 const childProc = require("child_process");
 
+const RegistryManagerClass = require("./registryManager");
+const registryManager = new RegistryManagerClass();
+
 // Constants
 
 const CRYPTO_SETTINGS_AES = {
@@ -18,6 +21,7 @@ const CRYPTO_SETTINGS_AES = {
   obfuscateStr: "eCybsseK",
   hash: "sha256",
 };
+const LMAK_SETTINGS_BASE = "EncSettings\\LMAK";
 
 /**
  *
@@ -70,14 +74,35 @@ class ConfigManager {
     this.encConfigPath = path.join(this.configDir, ".cache_2eafc8d0.dat"); // (雾
     /* ↑ 不使用 .tmp 扩展名, 不然容易真被清理了 */
     this.defaultConfigPath = path.join(__dirname, "default.json");
+    this.useEncConfig = false;
+    this.isConfigReadFailed = false;
+    this.side = "unknown";
+
+    if (fs.existsSync(this.configPath)) {
+      this.useEncConfig = false;
+    } else {
+      this.useEncConfig = true;
+    }
+
+    if (global.__HUGO_AURA_EVENT_BUS__) {
+      // Expect always true
+      global.__HUGO_AURA_EVENT_BUS__.on(
+        "$aura.config.updateConfigEncSettings",
+        (/** @type {boolean} */ newVal) => {
+          this.useEncConfig = newVal;
+        }
+      );
+    }
   }
 
   getHugoAuraConfigPath() {
-    return path.dirname(this.configPath);
+    return path.dirname(
+      this.useEncConfig ? this.encConfigPath : this.configPath
+    );
   }
 
   getConfigPath() {
-    return this.configPath;
+    return this.useEncConfig ? this.encConfigPath : this.configPath;
   }
 
   getDefaultConfig() {
@@ -99,7 +124,7 @@ class ConfigManager {
       fs.mkdirSync(hugoAuraPath, { recursive: true });
     }
 
-    if (!fs.existsSync(this.configPath)) {
+    if (!fs.existsSync(this.configPath) && !fs.existsSync(this.encConfigPath)) {
       console.log("[HugoAura / Config] Creating default config file");
       const defaultConfig = this.getDefaultConfig();
       this.writeConfig(defaultConfig);
@@ -108,11 +133,30 @@ class ConfigManager {
 
   readConfig() {
     try {
-      const config = JSON.parse(fs.readFileSync(this.configPath, "utf8"));
-      console.log("[HugoAura / Config] Successfully loaded config:", config);
+      let config = {};
+      if (this.useEncConfig) {
+        const hashedPasswdResultObj = this.retrieveEncPassword();
+        if (hashedPasswdResultObj.success && hashedPasswdResultObj.data) {
+          config = this.decryptConfig(hashedPasswdResultObj.data).data;
+
+          if (!config) {
+            this.isConfigReadFailed = true;
+            return this.getDefaultConfig(); // should be changed, too
+          }
+        } else {
+          console.error("[HugoAura / Config / ERROR] Failed to decrypt config");
+          this.isConfigReadFailed = true;
+          return this.getDefaultConfig(); // This behaviour should be changed later
+        }
+      } else {
+        config = JSON.parse(fs.readFileSync(this.configPath, "utf8"));
+      }
+      // console.log("[HugoAura / Config] Successfully loaded config:", config);
+      if (this.isConfigReadFailed) this.isConfigReadFailed = false;
       return config;
     } catch (err) {
       console.error("[HugoAura / Config] Failed to read config:", err);
+      this.isConfigReadFailed = true;
       return this.getDefaultConfig();
     }
   }
@@ -120,15 +164,32 @@ class ConfigManager {
   /**
    *
    * @param {Record<any, any>} config
-   * @returns
+   * @returns {Promise<boolean>}
    */
-  writeConfig(config) {
+  async writeConfig(config) {
     try {
-      fs.writeFileSync(
-        this.configPath,
-        JSON.stringify(config, null, 2),
-        "utf8"
-      );
+      if (this.useEncConfig) {
+        const hashedPasswdResultObj = await this.retrieveEncPasswordAsync();
+        if (hashedPasswdResultObj.success && hashedPasswdResultObj.data) {
+          this.encryptConfig(config, hashedPasswdResultObj.data);
+        } else {
+          console.error(
+            "[HugoAura / Config / Write / ERROR] Failed to write config: Retrieve enc password failed"
+          );
+          return false;
+        }
+      } else {
+        fs.writeFileSync(
+          this.configPath,
+          JSON.stringify(config, null, 2),
+          "utf8"
+        );
+      }
+
+      if (this.side === "renderer") {
+        global.ipcRenderer.send("$aura.config.refreshMainConfig");
+      }
+
       return true;
     } catch (err) {
       console.error("[HugoAura / Config] Failed to write config:", err);
@@ -140,8 +201,8 @@ class ConfigManager {
     let defaultConfig = this.getDefaultConfig();
     let config = {};
     try {
-      if (fs.existsSync(this.configPath)) {
-        const userConfig = JSON.parse(fs.readFileSync(this.configPath, "utf8"));
+      if (fs.existsSync(this.configPath) || fs.existsSync(this.encConfigPath)) {
+        const userConfig = this.readConfig();
         if (global.__HUGO_AURA__.configInit) {
           config = userConfig;
           return userConfig;
@@ -153,18 +214,340 @@ class ConfigManager {
       }
     } catch (err) {
       console.error("[HugoAura / Config] Failed to load user config:", err);
+      this.isConfigReadFailed = true;
       config = defaultConfig;
     }
 
     return config;
   }
 
+  priv_getMacAddr() {
+    const netInf = os.networkInterfaces();
+    const realInfs = Object.keys(netInf).filter(
+      (key) =>
+        !key.includes("Pseudo") &&
+        !key.includes("Loopback") &&
+        !key.includes("Virtual") &&
+        !key.includes("Tunnel") &&
+        !key.includes("Cisco") &&
+        !key.includes("VPN")
+    );
+
+    /**
+     *
+     * @param {string[]} infNames
+     * @param {Record<string, any>} infObj
+     * @returns
+     */
+    const getValidInfMac = (infNames, infObj) => {
+      for (const name of infNames) {
+        const target = infObj[name][0];
+        const isValid = !target.internal && target.mac !== "00:00:00:00:00:00";
+        if (isValid) {
+          return target.mac;
+        }
+      }
+      return null;
+    };
+
+    const rawInfMac = getValidInfMac(realInfs, netInf);
+    const macAddr = rawInfMac
+      ? rawInfMac.replace(/:/g, "").toUpperCase()
+      : null;
+    return macAddr;
+  }
+
+  /**
+   *
+   * @param {SHA256EncryptedPassword} password
+   */
+  async saveEncPassword(password) {
+    let macAddr = this.priv_getMacAddr();
+    let fallbackToStaticKey = false;
+
+    if (!macAddr) {
+      console.warn(
+        "[HugoAura / Config / LMK] No valid network inf found, fallback to static key."
+      );
+      macAddr = Buffer.from(crypto.randomBytes(6))
+        .toString("hex")
+        .toUpperCase();
+    }
+
+    const randomSalt = crypto.randomBytes(CRYPTO_SETTINGS_AES.saltLength);
+    const key = crypto.scryptSync(macAddr, randomSalt, 32);
+    const iv = crypto.randomBytes(CRYPTO_SETTINGS_AES.ivLength);
+
+    const cipherIns = crypto.createCipheriv(CRYPTO_SETTINGS_AES.mode, key, iv, {
+      // @ts-expect-error
+      authTagLength: CRYPTO_SETTINGS_AES.tagLength,
+    });
+
+    let encryptedPassword = cipherIns.update(password, "utf-8", "hex");
+    encryptedPassword += cipherIns.final("hex");
+
+    const authTagHex = cipherIns.getAuthTag().toString("hex");
+    const ivHex = iv.toString("hex");
+    const saltHex = randomSalt.toString("hex");
+
+    await registryManager.createOrUpdateRegKey(
+      LMAK_SETTINGS_BASE,
+      "LMAK_Value",
+      encryptedPassword,
+      true
+    );
+    await registryManager.createOrUpdateRegKey(
+      LMAK_SETTINGS_BASE,
+      "LMAK_IV",
+      ivHex,
+      true
+    );
+    await registryManager.createOrUpdateRegKey(
+      LMAK_SETTINGS_BASE,
+      "LMAK_Salt",
+      saltHex,
+      true
+    );
+    await registryManager.createOrUpdateRegKey(
+      LMAK_SETTINGS_BASE,
+      "LMAK_AuthTag",
+      authTagHex,
+      true
+    );
+
+    if (fallbackToStaticKey) {
+      await registryManager.createOrUpdateRegKey(
+        LMAK_SETTINGS_BASE,
+        "LMAK_FakeMac",
+        macAddr,
+        true
+      );
+    }
+
+    return true;
+  }
+
+  retrieveEncPassword() {
+    try {
+      const authTagHex = registryManager.readRegKeySync(
+        LMAK_SETTINGS_BASE,
+        "LMAK_AuthTag",
+        true
+      )?.data;
+      const ivHex = registryManager.readRegKeySync(
+        LMAK_SETTINGS_BASE,
+        "LMAK_IV",
+        true
+      )?.data;
+      const saltHex = registryManager.readRegKeySync(
+        LMAK_SETTINGS_BASE,
+        "LMAK_Salt",
+        true
+      )?.data;
+      const encPasswdHex = registryManager.readRegKeySync(
+        LMAK_SETTINGS_BASE,
+        "LMAK_Value",
+        true
+      )?.data;
+      let isStaticKey = false;
+      let macAddr = null;
+
+      try {
+        macAddr = registryManager.readRegKeySync(
+          LMAK_SETTINGS_BASE,
+          "LMAK_FakeMac",
+          true
+        )?.data;
+        if (!macAddr) {
+          isStaticKey = false;
+        } else {
+          isStaticKey = true;
+        }
+      } catch {
+        isStaticKey = false;
+      }
+
+      if (!isStaticKey) {
+        macAddr = this.priv_getMacAddr();
+
+        if (!macAddr) {
+          console.error(
+            "[HugoAura / Config / ERROR] Failed to retrieve password from reg: MAC Address invalid."
+          );
+          return {
+            success: false,
+            data: null,
+            error: new Error("Mac is null or undefined"),
+          };
+        }
+      }
+
+      if (!saltHex || !ivHex || !authTagHex || !encPasswdHex) {
+        console.error(
+          "[HugoAura / Config / ERROR] Failed to retrieve password from reg: Reg keys invalid."
+        );
+        return {
+          success: false,
+          data: null,
+          error: new Error("Reg key invalid"),
+        };
+      }
+      const salt = Buffer.from(saltHex, "hex");
+      const iv = Buffer.from(ivHex, "hex");
+      const authTag = Buffer.from(authTagHex, "hex");
+      const encPasswd = Buffer.from(encPasswdHex, "utf-8").toString();
+
+      const key = crypto.scryptSync(macAddr, salt, 32);
+      const decipherIns = crypto.createDecipheriv(
+        CRYPTO_SETTINGS_AES.mode,
+        key,
+        iv,
+        {
+          // @ts-expect-error
+          authTagLength: CRYPTO_SETTINGS_AES.tagLength,
+        }
+      );
+
+      decipherIns.setAuthTag(authTag);
+
+      const result = Buffer.concat([
+        decipherIns.update(encPasswd, "hex"),
+        decipherIns.final(),
+      ]).toString();
+
+      return {
+        success: true,
+        data: result,
+        error: null,
+      };
+    } catch (e) {
+      console.error(
+        "[HugoAura / Config / ERROR] Unexpected error occurred while retrieving password from reg, error:",
+        e
+      );
+      return {
+        success: false,
+        data: null,
+        error: e,
+      };
+    }
+  }
+
+  async retrieveEncPasswordAsync() {
+    try {
+      const authTagHex = (
+        await registryManager.readRegKey(
+          LMAK_SETTINGS_BASE,
+          "LMAK_AuthTag",
+          true
+        )
+      ).data;
+      const ivHex = (
+        await registryManager.readRegKey(LMAK_SETTINGS_BASE, "LMAK_IV", true)
+      ).data;
+      const saltHex = (
+        await registryManager.readRegKey(LMAK_SETTINGS_BASE, "LMAK_Salt", true)
+      ).data;
+      const encPasswdHex = (
+        await registryManager.readRegKey(LMAK_SETTINGS_BASE, "LMAK_Value", true)
+      ).data;
+      let isStaticKey = false;
+      let macAddr = null;
+
+      try {
+        macAddr = (
+          await registryManager.readRegKey(
+            LMAK_SETTINGS_BASE,
+            "LMAK_FakeMac",
+            true
+          )
+        ).data;
+        if (!macAddr) {
+          isStaticKey = false;
+        } else {
+          isStaticKey = true;
+        }
+      } catch {
+        isStaticKey = false;
+      }
+
+      if (!isStaticKey) {
+        macAddr = this.priv_getMacAddr();
+
+        if (!macAddr) {
+          console.error(
+            "[HugoAura / Config / ERROR] Failed to retrieve password from reg: MAC Address invalid."
+          );
+          return {
+            success: false,
+            data: null,
+            error: new Error("Mac is null or undefined"),
+          };
+        }
+      }
+
+      if (!saltHex || !ivHex || !authTagHex || !encPasswdHex) {
+        console.error(
+          "[HugoAura / Config / ERROR] Failed to retrieve password from reg: Reg keys invalid."
+        );
+        return {
+          success: false,
+          data: null,
+          error: new Error("Reg key invalid"),
+        };
+      }
+      const salt = Buffer.from(saltHex, "hex");
+      const iv = Buffer.from(ivHex, "hex");
+      const authTag = Buffer.from(authTagHex, "hex");
+      const encPasswd = Buffer.from(encPasswdHex, "utf-8").toString();
+
+      const key = crypto.scryptSync(macAddr, salt, 32);
+      const decipherIns = crypto.createDecipheriv(
+        CRYPTO_SETTINGS_AES.mode,
+        key,
+        iv,
+        {
+          // @ts-expect-error
+          authTagLength: CRYPTO_SETTINGS_AES.tagLength,
+        }
+      );
+
+      decipherIns.setAuthTag(authTag);
+
+      const result = Buffer.concat([
+        decipherIns.update(encPasswd, "hex"),
+        decipherIns.final(),
+      ]).toString();
+
+      return {
+        success: true,
+        data: result,
+        error: null,
+      };
+    } catch (e) {
+      console.error(
+        "[HugoAura / Config / ERROR] Unexpected error occurred while retrieving password from reg, error:",
+        e
+      );
+      return {
+        success: false,
+        data: null,
+        error: e,
+      };
+    }
+  }
+
+  async clearEncPasswdRegKey() {
+    await registryManager.delRegKey(LMAK_SETTINGS_BASE, null);
+  }
+
   /**
    *
    * @param {Record<any, any>} configData
-   * @param {string} passwd
+   * @param {SHA256EncryptedPassword} passwd
    */
   encryptConfig(configData, passwd) {
+    registryManager.initRegistrySync();
     const salt = crypto.randomBytes(CRYPTO_SETTINGS_AES.saltLength);
     const key = crypto.pbkdf2Sync(
       passwd,
@@ -198,15 +581,13 @@ class ConfigManager {
 
     try {
       fs.writeFileSync(this.encConfigPath, base64EncConfig, "utf-8");
-      // fs.rmSync(this.configPath);
+      try {
+        fs.unlinkSync(this.configPath);
+      } catch {
+        console.debug("[HugoAura / Config] Dec config not exists, skipping...");
+      }
 
-      const _hideFileProc = childProc.spawnSync(
-        "cmd.exe",
-        ["/c", "attrib", "+h", this.encConfigPath],
-        {
-          stdio: "inherit",
-        }
-      );
+      if (!this.useEncConfig) this.useEncConfig = true;
       return true;
     } catch (err) {
       console.error(
@@ -223,95 +604,169 @@ class ConfigManager {
 
   /**
    *
-   * @param {string} passwd
-   * @returns
+   * @param {SHA256EncryptedPassword} passwd
+   * @returns {{success: boolean, data: AuraConfig}}
    */
   decryptConfig(passwd) {
-    const FAILED_RET = {
-      success: false,
-      data: {},
-    };
-
-    let base64EncConfig = null;
-
     try {
-      if (!fs.existsSync(this.encConfigPath)) {
-        return FAILED_RET;
-      }
-      base64EncConfig = fs.readFileSync(this.encConfigPath, "utf-8");
-    } catch (err) {
-      console.error(
-        "[HugoAura / Config] Failed to read encrypted config:",
-        err
-      );
-      return FAILED_RET;
-    }
+      const FAILED_RET = {
+        success: false,
+        data: {},
+      };
+
+      let base64EncConfig = null;
 
-    if (base64EncConfig) {
-      const strip64EncCfg = base64EncConfig.split(
-        CRYPTO_SETTINGS_AES.obfuscateStr
-      )[1];
-      const encryptCfg = Buffer.from(strip64EncCfg, "base64").toString("utf-8");
-      /** @type {null | EncryptedConfig} */
-      let parsedEncCfg = null;
       try {
-        parsedEncCfg = JSON.parse(encryptCfg);
-      } catch (err) {
-        console.error(
-          "[HugoAura / Config] Failed to parse encrypted config:",
-          err
-        );
-        console.error("[HugoAura / Config] Pending data:", encryptCfg);
-      }
-      if (parsedEncCfg === null) return FAILED_RET;
-
-      const salt = Buffer.from(parsedEncCfg.salt, "base64");
-      const iv = Buffer.from(parsedEncCfg.iv, "base64");
-
-      const authTag = Buffer.from(parsedEncCfg.authTag, "base64");
-
-      const key = crypto.pbkdf2Sync(
-        passwd,
-        salt,
-        CRYPTO_SETTINGS_AES.keyIter,
-        CRYPTO_SETTINGS_AES.keyLength,
-        CRYPTO_SETTINGS_AES.hash
-      );
-
-      const decipherIns = crypto.createDecipheriv(
-        CRYPTO_SETTINGS_AES.mode,
-        key,
-        iv,
-        {
-          // @ts-expect-error
-          authTagLength: CRYPTO_SETTINGS_AES.tagLength,
+        if (!fs.existsSync(this.encConfigPath)) {
+          return FAILED_RET;
         }
-      );
-
-      decipherIns.setAuthTag(authTag);
-
-      let stringifyDecCfg = Buffer.concat([
-        decipherIns.update(parsedEncCfg.content, "hex"),
-        decipherIns.final(),
-      ]).toString();
-
-      /** @type {null | Record<any, any>} */
-      let decConfig = null;
-      try {
-        decConfig = JSON.parse(stringifyDecCfg);
+        base64EncConfig = fs.readFileSync(this.encConfigPath, "utf-8");
       } catch (err) {
         console.error(
-          "[HugoAura / Config] Failed to parse decrypted config:",
+          "[HugoAura / Config] Failed to read encrypted config:",
           err
         );
-        console.error("[HugoAura / Config] Pending data:", decConfig);
         return FAILED_RET;
       }
-      if (decConfig === null) return FAILED_RET;
 
-      console.debug(decConfig);
+      if (base64EncConfig) {
+        const strip64EncCfg = base64EncConfig.split(
+          CRYPTO_SETTINGS_AES.obfuscateStr
+        )[1];
+        const encryptCfg = Buffer.from(strip64EncCfg, "base64").toString(
+          "utf-8"
+        );
+        /** @type {null | EncryptedConfig} */
+        let parsedEncCfg = null;
+        try {
+          parsedEncCfg = JSON.parse(encryptCfg);
+        } catch (err) {
+          console.error(
+            "[HugoAura / Config] Failed to parse encrypted config:",
+            err
+          );
+          console.error("[HugoAura / Config] Pending data:", encryptCfg);
+        }
+        if (parsedEncCfg === null) return FAILED_RET;
+
+        const salt = Buffer.from(parsedEncCfg.salt, "base64");
+        const iv = Buffer.from(parsedEncCfg.iv, "base64");
+
+        const authTag = Buffer.from(parsedEncCfg.authTag, "base64");
+
+        const key = crypto.pbkdf2Sync(
+          passwd,
+          salt,
+          CRYPTO_SETTINGS_AES.keyIter,
+          CRYPTO_SETTINGS_AES.keyLength,
+          CRYPTO_SETTINGS_AES.hash
+        );
+
+        const decipherIns = crypto.createDecipheriv(
+          CRYPTO_SETTINGS_AES.mode,
+          key,
+          iv,
+          {
+            // @ts-expect-error
+            authTagLength: CRYPTO_SETTINGS_AES.tagLength,
+          }
+        );
+
+        decipherIns.setAuthTag(authTag);
+
+        const stringifyDecCfg = Buffer.concat([
+          decipherIns.update(parsedEncCfg.content, "hex"),
+          decipherIns.final(),
+        ]).toString();
+
+        /** @type {null | Record<any, any>} */
+        let decConfig = null;
+        try {
+          decConfig = JSON.parse(stringifyDecCfg);
+        } catch (err) {
+          console.error(
+            "[HugoAura / Config] Failed to parse decrypted config:",
+            err
+          );
+          console.error("[HugoAura / Config] Pending data:", decConfig);
+          return FAILED_RET;
+        }
+        if (decConfig === null) return FAILED_RET;
+
+        // console.debug(decConfig);
+
+        return {
+          success: true,
+          data: decConfig,
+        };
+      } else {
+        console.error(
+          "[HugoAura / Config] Unexpected error occurred while decrypting config: base64EncConfig is undefined"
+        );
+        return FAILED_RET;
+      }
+    } catch (e) {
+      console.error(
+        "[HugoAura / Config] Unexpected error occurred while decrypting config:",
+        e
+      );
+      return {
+        success: false,
+        data: {},
+      };
     }
   }
+
+  /**
+   *
+   * @param {Record<any, any> | null} curConfig
+   * @param {SHA256EncryptedPassword | undefined | null} passwd
+   * @returns {Promise<{success: boolean}>}
+   */
+  async switchToDecConfig(curConfig, passwd = null) {
+    let decConfig = null;
+    if (!curConfig && passwd) {
+      const getDecConfigResult = this.decryptConfig(passwd);
+      if (
+        !getDecConfigResult?.success ||
+        !getDecConfigResult.data ||
+        Object.keys(getDecConfigResult.data).length === 0
+      ) {
+        console.error(
+          "[HugoAura / Config] Failed to switch to decrypted config: Error decrypting config"
+        );
+        return {
+          success: false,
+        };
+      }
+      decConfig = getDecConfigResult.data;
+    }
+
+    this.useEncConfig = false;
+    await this.clearEncPasswdRegKey();
+    // @ts-expect-error
+    this.writeConfig(curConfig ? curConfig : decConfig);
+    try {
+      fs.unlinkSync(this.encConfigPath);
+    } catch {
+      console.debug("[HugoAura / Config] Enc config not exists, skipping...");
+    }
+    global.__HUGO_AURA_EVENT_BUS__.emit(
+      "$aura.config.updateConfigEncSettings",
+      false
+    );
+    if (this.side === "renderer") {
+      global.ipcRenderer.invoke("$aura.config.setConfigEncSettings", {
+        target: false,
+      });
+      global.ipcRenderer.invoke("$aura.config.dispatchConfigFromRenderer", {
+        data: JSON.stringify(curConfig),
+      });
+    }
+    return {
+      success: true,
+    };
+  }
 }
 
-module.exports = new ConfigManager();
+module.exports = ConfigManager;

src/aura/init/shared/default.json

@@ -7,7 +7,7 @@
         "passwordWithSalt": "89f6c4d57d0202a05c32d37cc6a2c6a0",
         "salt": "aura"
       },
-      "authModeRewrite": "none"
+      "authModeRewrite": "default"
     },
     "vendor/screenLock": {
       "enabled": true,
@@ -26,13 +26,11 @@
       "enabled": true
     }
   },
-  "plsToken": "66ccff0d000721114514191981023333",
   "auraSettings": {
     "settingsPasswordEnabled": false,
     "settingsPasswordWithSalt": "32703D292460CC9A3B867494D6AD9A8E4A3ADF0FAA4D6867BC4D412CC3927D02E47C6D0B1763BB53E57B2241C6193433561CDA09D7C48CA03983072B876F0965",
-    "appearance": {
-      "enablePasswdDialogBlur": true
-    }
+    "encryptConfig": false,
+    "appearance": {}
   },
   "devTools": false
 }

src/aura/init/shared/registryManager.js

@@ -0,0 +1,469 @@
+// @ts-check
+
+const { exec, execSync } = require("child_process");
+
+// Constants
+
+const LOG_PREFIX = "[HugoAura / Init / Reg";
+const LOG_PREFIX_FUNC = "[HugoAura / Reg";
+const AURA_REGISTRY_PATH = ["HKEY_USERS", ".DEFAULT", "SOFTWARE", "HugoAura"].join("\\");
+
+class RegistryManager {
+  /**
+   * @param {string} [path]
+   * @returns {Promise<boolean>}
+   */
+  async handleCreateReg(path) {
+    try {
+      const { stdout } = await new Promise((resolve, reject) => {
+        exec(
+          ["reg", "add", path].join(" "),
+          { encoding: "utf8" },
+          (error, stdout, stderr) => {
+            if (error) reject(error);
+            else resolve({ stdout, stderr });
+          }
+        );
+      });
+
+      console.log(
+        `${LOG_PREFIX} / SUCCESS] Registry path ${path} successfully created.`
+      );
+      console.debug(`${LOG_PREFIX} / DEBUG] Reg add command stdout:`, stdout);
+      return true;
+    } catch (e) {
+      console.error(
+        `${LOG_PREFIX} / ERROR] Failed creating registry path, error:`,
+        e
+      );
+      return false;
+    }
+  }
+
+  /**
+   * @param {string} [path]
+   * @returns {boolean}
+   */
+  handleCreateRegSync(path) {
+    try {
+      const createResult = execSync(["reg", "add", path].join(" "), {
+        encoding: "utf8",
+      });
+
+      if (createResult) {
+        console.log(
+          `${LOG_PREFIX} / SUCCESS] Registry path ${path} successfully created.`
+        );
+        console.debug(
+          `${LOG_PREFIX} / DEBUG] Reg add command stdout:`,
+          createResult
+        );
+        return true;
+      } else {
+        return false;
+      }
+    } catch (e) {
+      console.error(
+        `${LOG_PREFIX} / ERROR] Failed creating registry path, error:`,
+        e
+      );
+      return false;
+    }
+  }
+
+  /**
+   * @returns {Promise<boolean>}
+   */
+  async initRegistry() {
+    try {
+      const { stdout } = await new Promise((resolve, reject) => {
+        exec(
+          ["reg", "query", AURA_REGISTRY_PATH].join(" "),
+          { encoding: "utf8" },
+          (error, stdout, stderr) => {
+            if (error) reject(error);
+            else resolve({ stdout, stderr });
+          }
+        );
+      });
+
+      console.log(`${LOG_PREFIX}] Registry check up success.`);
+      console.debug(`${LOG_PREFIX}] Command stdout:`, stdout);
+      return true;
+    } catch (e) {
+      console.warn(`${LOG_PREFIX} / WARN] Failed to query registry, error:`, e);
+      return await this.handleCreateReg(AURA_REGISTRY_PATH);
+    }
+  }
+
+  /**
+   * @returns {boolean}
+   */
+  initRegistrySync() {
+    try {
+      const queryResult = execSync(
+        ["reg", "query", AURA_REGISTRY_PATH].join(" "),
+        { encoding: "utf8" }
+      );
+
+      if (queryResult) {
+        console.log(`${LOG_PREFIX}] Registry check up success.`);
+        console.debug(`${LOG_PREFIX}] Command stdout:`, queryResult);
+        return true;
+      } else {
+        return false;
+      }
+    } catch (e) {
+      console.warn(`${LOG_PREFIX} / WARN] Failed to query registry, error:`, e);
+      return this.handleCreateRegSync(AURA_REGISTRY_PATH);
+    }
+  }
+
+  /**
+   * @param {string} relativePath
+   * @param {string} keyName
+   * @param {string} keyVal
+   * @param {boolean | undefined} silent
+   * @returns {Promise<{ success: boolean, error: Error | null }>}
+   */
+  async createOrUpdateRegKey(relativePath, keyName, keyVal, silent = false) {
+    try {
+      const { stdout } = await new Promise((resolve, reject) => {
+        exec(
+          [
+            "reg",
+            "add",
+            [AURA_REGISTRY_PATH, relativePath].join("\\"),
+            "/v",
+            keyName,
+            "/t",
+            "REG_SZ",
+            "/d",
+            `\"${keyVal}\"`,
+            "/f",
+          ].join(" "),
+          { encoding: "utf8" },
+          (error, stdout, stderr) => {
+            if (error) reject(error);
+            else resolve({ stdout, stderr });
+          }
+        );
+      });
+
+      if (!silent) {
+        console.debug(
+          `${LOG_PREFIX_FUNC} / SUCCESS] Successfully created / updated reg key ${relativePath}/${keyName} with data: ${keyVal}`
+        );
+        console.debug(
+          `${LOG_PREFIX_FUNC} / SUCCESS] Add key command stdout:`,
+          stdout
+        );
+      }
+      return {
+        success: true,
+        error: null,
+      };
+    } catch (e) {
+      console.error(
+        `${LOG_PREFIX_FUNC} / ERROR] Failed to create / update reg key, error:`,
+        silent ? "<Hidden>" : e
+      );
+      return {
+        success: false,
+        error: e,
+      };
+    }
+  }
+
+  /**
+   * @param {string} relativePath
+   * @param {string} keyName
+   * @param {string} keyVal
+   * @param {boolean | undefined} silent
+   * @returns {{ success: boolean, error: Error | null }}
+   */
+  createOrUpdateRegKeySync(relativePath, keyName, keyVal, silent = false) {
+    try {
+      const result = execSync(
+        [
+          "reg",
+          "add",
+          [AURA_REGISTRY_PATH, relativePath].join("\\"),
+          "/v",
+          keyName,
+          "/t",
+          "REG_SZ",
+          "/d",
+          `\"${keyVal}\"`,
+          "/f",
+        ].join(" "),
+        { encoding: "utf8" }
+      );
+
+      if (result) {
+        if (!silent) {
+          console.debug(
+            `${LOG_PREFIX} / SUCCESS] Successfully created / updated reg key ${relativePath}/${keyName} with data: ${keyVal}`,
+            result
+          );
+          console.error("");
+        }
+      }
+      return {
+        success: true,
+        error: null,
+      };
+    } catch (e) {
+      console.error(
+        `${LOG_PREFIX_FUNC} / ERROR] Failed to create / update reg key error:`,
+        e
+      );
+      return {
+        success: false,
+        error: e,
+      };
+    }
+  }
+
+  /**
+   * @param {string} relativePath
+   * @param {string | null} keyName
+   * @param {boolean | undefined} silent
+   * @returns {Promise<{ success: boolean, error: Error | null }>}
+   */
+  async delRegKey(relativePath, keyName, silent = false) {
+    if (keyName === undefined) {
+      throw new Error(
+        `${LOG_PREFIX_FUNC} / CRITICAL] Arg \"keyName\" for function \"delRegKey\" cannot be undefined. Only null or null accepted.`
+      );
+    }
+
+    try {
+      const { stdout } = await new Promise((resolve, reject) => {
+        exec(
+          [
+            "reg",
+            "delete",
+            [AURA_REGISTRY_PATH, relativePath].join("\\"),
+            keyName ? "/v" : "",
+            keyName ? keyName : "",
+            "/f",
+          ].join(" "),
+          { encoding: "utf8" },
+          (error, stdout, stderr) => {
+            if (error) reject(error);
+            else resolve({ stdout, stderr });
+          }
+        );
+      });
+
+      if (!silent) {
+        console.debug(
+          `${LOG_PREFIX_FUNC} / SUCCESS] Successfully deleted reg key ${relativePath}/${keyName}`
+        );
+        console.debug(
+          `${LOG_PREFIX_FUNC} / SUCCESS] Delete key command stdout:`,
+          stdout
+        );
+      }
+      return {
+        success: true,
+        error: null,
+      };
+    } catch (e) {
+      console.error(
+        `${LOG_PREFIX_FUNC} / ERROR] Failed to delete reg key, error:`,
+        silent ? "<Hidden>" : e
+      );
+      return {
+        success: false,
+        error: e,
+      };
+    }
+  }
+
+  /**
+   * @param {string} relativePath
+   * @param {string | null} keyName
+   * @param {boolean | undefined} silent
+   * @returns {{ success: boolean, error: Error | null }}
+   */
+  delRegKeySync(relativePath, keyName, silent = false) {
+    if (keyName === undefined) {
+      throw new Error(
+        `${LOG_PREFIX_FUNC} / CRITICAL] Arg \"keyName\" for function \"delRegKeySync\" cannot be undefined. Only null or string accepted.`
+      );
+    }
+
+    try {
+      const result = execSync(
+        [
+          "reg",
+          "delete",
+          [AURA_REGISTRY_PATH, relativePath].join("\\"),
+          keyName ? "/v" : "",
+          keyName ? keyName : "",
+          "/f",
+        ].join(" "),
+        { encoding: "utf8" }
+      );
+
+      if (result) {
+        if (!silent) {
+          console.debug(
+            `${LOG_PREFIX_FUNC} / SUCCESS] Successfully deleted reg key ${relativePath}/${keyName}`
+          );
+          console.debug(
+            `${LOG_PREFIX_FUNC} / SUCCESS] Delete key command stdout:`,
+            result
+          );
+        }
+        return {
+          success: true,
+          error: null,
+        };
+      } else {
+        return {
+          success: false,
+          error: null,
+        };
+      }
+    } catch (e) {
+      console.error(
+        `${LOG_PREFIX_FUNC} / ERROR] Failed to delete reg key, error:`,
+        silent ? "<Hidden>" : e
+      );
+      return {
+        success: false,
+        error: e,
+      };
+    }
+  }
+
+  /**
+   * @param {string} relativePath
+   * @param {string} keyName
+   * @param {boolean | undefined} silent
+   * @returns {Promise<{ success: boolean, data: string | null, error: Error | null }>}
+   */
+  async readRegKey(relativePath, keyName, silent = false) {
+    try {
+      const { stdout } = await new Promise((resolve, reject) => {
+        exec(
+          [
+            "reg",
+            "query",
+            [AURA_REGISTRY_PATH, relativePath].join("\\"),
+            "/v",
+            `\"${keyName}\"`,
+          ].join(" "),
+          { encoding: "utf8" },
+          (error, stdout, stderr) => {
+            if (error) reject(error);
+            else resolve({ stdout, stderr });
+          }
+        );
+      });
+
+      if (!silent) {
+        console.debug(
+          `${LOG_PREFIX_FUNC} / SUCCESS] Successfully read reg key ${relativePath}/${keyName}, stdout:`,
+          stdout
+        );
+      }
+
+      const match = stdout.match(/REG_SZ\s+(.+)/);
+
+      if (!match) {
+        console.warn(`${LOG_PREFIX} / WARN] Data not found in stdout`);
+        return {
+          success: false,
+          data: null,
+          error: new Error("Data not found"),
+        };
+      }
+
+      const data = match[1].trim();
+      return {
+        success: true,
+        data,
+        error: null,
+      };
+    } catch (e) {
+      console.error(
+        `${LOG_PREFIX} / ERROR] Failed to read reg key, error:`,
+        e
+      );
+      return {
+        success: false,
+        data: null,
+        error: e,
+      };
+    }
+  }
+
+  /**
+   * @param {string} relativePath
+   * @param {string} keyName
+   * @param {boolean | undefined} silent
+   * @returns {{ success: boolean, data: string | null, error: Error | null }}
+   */
+  readRegKeySync(relativePath, keyName, silent = false) {
+    try {
+      const readResult = execSync(
+        [
+          "reg",
+          "query",
+          [AURA_REGISTRY_PATH, relativePath].join("\\"),
+          "/v",
+          `\"${keyName}\"`,
+        ].join(" "),
+        { encoding: "utf8" }
+      );
+
+      if (readResult) {
+        if (!silent) {
+          console.debug(
+            `${LOG_PREFIX_FUNC} / SUCCESS] Successfully read reg key ${relativePath}/${keyName}, stdout:`,
+            readResult
+          );
+        }
+        const match = readResult.match(/REG_SZ\s+(.+)/);
+
+        if (!match) {
+          console.warn(`${LOG_PREFIX} / WARN] Data not found in stdout`);
+          return {
+            success: false,
+            data: null,
+            error: new Error("Data not found"),
+          };
+        }
+
+        const data = match[1].trim();
+        return {
+          success: true,
+          data,
+          error: null,
+        };
+      } else {
+        return {
+          success: false,
+          data: null,
+          error: null,
+        };
+      }
+    } catch (e) {
+      console.error(
+        `${LOG_PREFIX} / ERROR] Failed to read reg key, error:`,
+        silent ? "<Hidden>" : e
+      );
+      return {
+        success: false,
+        data: null,
+        error: e,
+      };
+    }
+  }
+}
+
+module.exports = RegistryManager;

src/aura/types/main/core.d.ts

@@ -21,13 +21,6 @@ type HookedWindowsMap = Map<WindowName, HookedWindow>;
 
 type HookRequire = any;
 
-type HooksMap = Map<WindowName, HookRequire>;
+type UIHooksMap = Map<WindowName, HookRequire>;
 
-interface MainProcessGlobal {
-  hookedWindows: HookedWindowsMap;
-  hooks: HooksMap;
-  configInit: boolean;
-  plsStats: PLSStatus | null;
-  plsSettings: Record<any, any> | null;
-  plsRules: Record<any, any> | null;
-}
+type WindowHooksMap = Map<WindowName, HookRequire>;

src/aura/types/main/ipc/fs.d.ts

@@ -0,0 +1,21 @@
+type DownloadTaskID = string;
+type DownloadTaskStatus = "waiting" | "progressing" | "done" | "failed" | "cancelled" | "struggling";
+
+interface DownloadTask {
+  id: DownloadTaskID;
+  progress: float;
+  curBytes?: number;
+  totalBytes?: number;
+  status: DownloadTaskStatus;
+  dlUrl: string | null;
+  savePath: string | null;
+  message?: string;
+  errorObj?: Error;
+}
+
+interface FSTasks {
+  downloadTasks: Map<
+    DownloadTaskID,
+    { status: DownloadTaskStatus; cancelReq: any }
+  >;
+}

src/aura/types/render/global.d.ts

@@ -12,3 +12,6 @@ interface DesktopAssistantHugoAuraGlobal extends HugoAuraGlobal {
   plsWs: WebSocket | null;
   plsStats: PLSStatus;
 }
+
+type UIFunctionsObject = Record<string, any>;
+type UIReactivesObject = Record<string, any>;

src/aura/types/render/uiHook.d.ts

@@ -1,12 +1,13 @@
 import { WindowName } from "../main/core";
 
 interface UIHookTarget {
-  active: boolean;
-  pageURI: string;
-  pageScript: string;
-  pageSelector: string;
-  selectorMode: "insertAfter" | "insertBefore" | "appendChild";
-  pageCSS: string;
+  active?: boolean;
+  pageURI?: string;
+  pageScript?: string;
+  pageSelector?: string;
+  selectorMode?: "insertAfter" | "insertBefore" | "appendChild";
+  pageCSS?: string;
+  childs?: Record<AuraElementUID, UIHookTarget>;
   revive?: boolean;
 }
 
@@ -23,3 +24,5 @@ interface UIHookConfig {
 interface UIHookConfigFin extends UIHookConfig {
   windowName: WindowName;
 }
+
+type UIHooksObject = Record<AuraElementUID, UIHookConfigFin>;

src/aura/types/shared/config.d.ts

@@ -1,5 +1,6 @@
 type AES256EncryptedConfig = string;
 type Base64String = string;
+type SHA256EncryptedPassword = string;
 
 interface EncryptedConfig {
   content: AES256EncryptedConfig;
@@ -7,3 +8,5 @@ interface EncryptedConfig {
   salt: Base64String;
   iv: Base64String;
 }
+
+type AuraConfig = Record<any, any>;

src/aura/types/shared/global.d.ts

@@ -0,0 +1,48 @@
+import { IpcRenderer } from "electron";
+import type EventBus from "../../utils/eventBus";
+import { HookedWindowsMap, UIHooksMap, WindowHooksMap } from "../main/core";
+import { UIHooksObject } from "../render/uiHook";
+import ConfigManager from "../../init/shared/configManager";
+import { PLSStatus } from "./pls/status";
+
+type MainProcessOnlyVal<T> = T;
+type RendererProcessOnlyVal<T> = T;
+
+interface GlobalHugoAuraInfo {
+  central?: MainProcessOnlyVal<(...args: any) => any>;
+  configInit: boolean;
+  fsTasks?: MainProcessOnlyVal<FSTasks>;
+  hookedWindows?: MainProcessOnlyVal<HookedWindowsMap>;
+  ipcInit?: MainProcessOnlyVal<boolean>;
+  plsRules?: Record<any, any> | null;
+  plsSettings?: Record<any, any> | null;
+  plsStats?: PLSStatus | null;
+  plsWs?: RendererProcessOnlyVal<WebSocket>;
+  uiHooks?: MainProcessOnlyVal<UIHooksMap>;
+  windowHooks?: MainProcessOnlyVal<WindowHooksMap>;
+  version: RendererProcessOnlyVal<string>;
+}
+
+interface GlobalHugoAuraApiInfo {
+  domains: string[];
+  plsUpdate: string;
+  auraUpdate: string;
+}
+
+type GlobalHugoAuraConfig = AuraConfig;
+
+declare global {
+  var ipcRenderer: RendererProcessOnlyVal<IpcRenderer>;
+  var _ACCEPT_DATA: any;
+  var __HUGO_AURA__: GlobalHugoAuraInfo;
+  var __HUGO_AURA_API__: GlobalHugoAuraApiInfo;
+  var __HUGO_AURA_CONFIG__: GlobalHugoAuraConfig;
+  var __HUGO_AURA_CONFIG_MGR__: ConfigManager;
+  var __HUGO_AURA_EVENT_BUS__: EventBus;
+  var __HUGO_AURA_DEBUG__: RendererProcessOnlyVal<Record<any, any>>;
+  var __HUGO_AURA_GLOBAL__: RendererProcessOnlyVal<Record<any, any>>;
+  var __HUGO_AURA_HOOK__: RendererProcessOnlyVal<Record<any, any>>;
+  var __HUGO_AURA_LOADER__: RendererProcessOnlyVal<UIHooksObject>;
+  var __HUGO_AURA_UI_FUNCTIONS__: RendererProcessOnlyVal<UIFunctionsObject>;
+  var __HUGO_AURA_UI_REACTIVES__: RendererProcessOnlyVal<UIReactivesObject>;
+}

src/aura/types/shared/pls/status.d.ts

@@ -1,9 +1,28 @@
+import { RendererProcessOnlyVal } from "../global";
+
+type PLSStatusDesc =
+  | "dead"
+  | "running"
+  | "notReady"
+  | "downloading"
+  | "notInstalled";
+
 interface PLSStatus {
   installed: boolean;
   detached: boolean;
   connected: boolean;
   launched: boolean;
-  status: string;
+  status: PLSStatusDesc;
   version: string;
   authToken: string;
 }
+
+type PLSLifecycleType = "isDetached" | "isSvcInstalled" | "isSvcStart";
+
+type PLSLifecycleControlType =
+  | "instSvc"
+  | "rmSvc"
+  | "startSvc"
+  | "stopSvc"
+  | "rmBin"
+  | "dlBin";

src/aura/ui/composables/plsConfigManager.js

@@ -8,7 +8,7 @@ const updatePlsStatusFromLocal = async () => {
   const plsStatus = (
     await global.ipcRenderer.invoke(`${IPC_METHOD_BASE}.getPlsStats`)
   ).data;
-  global.__HUGO_AURA_GLOBAL__.plsStatus = plsStatus;
+  global.__HUGO_AURA__.plsStats = plsStatus;
   return plsStatus;
 };
 
@@ -16,7 +16,7 @@ const updatePlsSettingsFromLocal = async () => {
   const plsSettings = (
     await global.ipcRenderer.invoke(`${IPC_METHOD_BASE}.getPlsSettings`)
   ).data;
-  global.__HUGO_AURA_GLOBAL__.plsSettings = plsSettings;
+  global.__HUGO_AURA__.plsSettings = plsSettings;
   return plsSettings;
 };
 
@@ -24,22 +24,11 @@ const updatePlsRulesFromLocal = async () => {
   const plsRules = (
     await global.ipcRenderer.invoke(`${IPC_METHOD_BASE}.getPlsRules`)
   ).data;
-  global.__HUGO_AURA_GLOBAL__.plsRules = plsRules;
+  global.__HUGO_AURA__.plsRules = plsRules;
   return plsRules;
 };
 
-/**
- *
- * @returns {string}
- */
-const genRandomHex = () => {
-  let result = "";
-  for (let i = 0; i < 8; i++) {
-    const randomNum = Math.floor(Math.random() * 0x10000);
-    result += randomNum.toString(16).padStart(4, "0");
-  }
-  return result;
-};
+const { genRandomHex } = require("../../utils/crypto");
 
 /**
  *
@@ -48,23 +37,22 @@ const genRandomHex = () => {
  */
 const updatePlsConfigToRemote = async (configKey, configValue) => {
   const configLevels = configKey.split(".");
-  /** @type {Record<any, any>} */
-  let localUpdateTarget =
-    configLevels[0] === "ruleSettings"
-      ? global.__HUGO_AURA_GLOBAL__.plsRules
-      : global.__HUGO_AURA_GLOBAL__.plsSettings;
-  for (const level of configLevels.slice(0, -1)) {
-    localUpdateTarget = localUpdateTarget[level];
-  }
-  localUpdateTarget[configLevels.slice(-1)[0]] = configValue;
 
   const plsConfigUpdateEvent = new CustomEvent("onPLSConfigUpdate", {
     detail: {
-      path: configKey,
+      path: configLevels,
       value: configValue,
     },
   });
   document.dispatchEvent(plsConfigUpdateEvent);
+  const settingsEntries = document.getElementsByClassName(
+    "aura-settings-entry"
+  );
+  if (settingsEntries.length > 0) {
+    Array.from(settingsEntries).forEach((entry) => {
+      entry.dispatchEvent(plsConfigUpdateEvent);
+    });
+  }
 
   /**
    * @type {ClientPLSRequest}
@@ -80,8 +68,8 @@ const updatePlsConfigToRemote = async (configKey, configValue) => {
 
   global.ipcRenderer.invoke(`${IPC_METHOD_BASE}.ws.sendWsMessage`, data);
   global.ipcRenderer.invoke(`${IPC_METHOD_BASE}.syncPlsConfig`, {
-    basic: global.__HUGO_AURA_GLOBAL__.plsSettings,
-    rules: global.__HUGO_AURA_GLOBAL__.plsRules,
+    basic: global.__HUGO_AURA__.plsSettings,
+    rules: global.__HUGO_AURA__.plsRules,
   });
 };
 

src/aura/ui/composables/settingsRenderer.js

@@ -22,7 +22,7 @@ const showRelaunchPLSToast = () => {
   const toast = document.getElementById("relaunchPlsNotifyToast");
   const toastBs = bootstrap.Toast.getOrCreateInstance(toast);
 
-  if (global.__HUGO_AURA_GLOBAL__.plsStatus.detached) {
+  if (global.__HUGO_AURA__.plsStats.detached) {
     const relaunchBtn = document.getElementById("plsRelaunchBtn");
     relaunchBtn.disabled = true;
     relaunchBtn.textContent = "分离模式下无法执行";
@@ -36,12 +36,331 @@ const showToast = (entry) => {
     showReloadToast();
   } else if (entry.restart) {
     showRelaunchToast();
-  } else if (entry.restartPLS) {
+  }
+
+  /*
+  else if (entry.restartPLS) {
     showRelaunchPLSToast();
   }
+  */
+};
+
+const insertOrRemoveEl = (parent, child, isInsert = true) => {
+  if (Array.isArray(child)) {
+    for (const perEl of child) {
+      isInsert ? parent.appendChild(perEl) : parent.removeChild(perEl);
+    }
+  } else {
+    isInsert ? parent.appendChild(child) : parent.removeChild(child);
+  }
 };
 
-const settingsRenderer = (pendingEl, settingsObj, isPls = false) => {
+const createOnLeaveEvtListener =
+  global.__HUGO_AURA_GLOBAL__.utils.createOnLeaveEvtListener;
+
+const renderInputArea = (entry, operationArea, descriptionArea) => {
+  switch (entry.type) {
+    case "switch": {
+      const switchEl = document.createElement("input");
+      switchEl.classList.add("form-check-input");
+      switchEl.type = "checkbox";
+      switchEl.role = "switch";
+      switchEl.id = entry.id;
+      const elValue = entry.valueGetter();
+      switchEl.value = elValue;
+      switchEl.checked = elValue;
+      switchEl.addEventListener("change", async (event) => {
+        showToast(entry);
+        await entry.callbackFn(event.target.checked);
+      });
+      operationArea.classList.add("form-check", "form-switch");
+      return switchEl;
+    }
+    case "radio": {
+      const elValue = entry.valueGetter();
+      const elArr = [];
+      for (const template of entry.templates) {
+        const inlineContainerEl = document.createElement("div");
+        inlineContainerEl.classList.add("form-check", "form-check-inline");
+        const radioEl = document.createElement("input");
+        radioEl.value = template;
+        radioEl.classList.add("form-check-input");
+        radioEl.type = "radio";
+        radioEl.name = `${entry.id}Radios`;
+        radioEl.id = `${entry.id}Radio${entry.templates.indexOf(template)}`;
+        radioEl.checked = template === elValue ? true : false;
+        radioEl.addEventListener("change", async (event) => {
+          if (event.target.checked) {
+            showToast(entry);
+            await entry.callbackFn(event.target.value);
+          }
+        });
+        inlineContainerEl.appendChild(radioEl);
+        const labelEl = document.createElement("label");
+        labelEl.classList.add("form-check-label");
+        labelEl.setAttribute("for", radioEl.id);
+        labelEl.textContent =
+          entry.templateLabels[entry.templates.indexOf(template)];
+        inlineContainerEl.appendChild(labelEl);
+        elArr.push(inlineContainerEl);
+      }
+      return elArr;
+    }
+    case "input": {
+      const inputEl = document.createElement("input");
+      inputEl.classList.add("form-control");
+      inputEl.type = entry.subType;
+      inputEl.value = entry.valueGetter();
+      inputEl.placeholder = entry.placeHolder;
+      inputEl.id = entry.id;
+      inputEl.addEventListener("change", async (event) => {
+        const result = await entry.callbackFn(event.target.value);
+        const success = result.valid;
+        if (success) {
+          showToast(entry);
+
+          if (inputEl.className.includes("is-invalid")) {
+            inputEl.classList.remove("is-invalid");
+            descriptionArea.textContent = entry.description;
+            descriptionArea.classList.remove("ase-desc-error-hint");
+          }
+        } else {
+          inputEl.classList.add("is-invalid");
+          descriptionArea.textContent = result.hint;
+          descriptionArea.classList.add("ase-desc-error-hint");
+        }
+      });
+      operationArea.classList.add("ase-operation-area-expanded");
+      return inputEl;
+    }
+    default:
+      break;
+  }
+};
+
+const renderNormalSettingsItem = (entry, formEl) => {
+  const entryContainerEl = document.createElement("div");
+  entryContainerEl.classList.add("aura-settings-entry");
+  entryContainerEl.id = `${entry.id}Container`;
+
+  const entryInfoContainerEl = document.createElement("div");
+  entryInfoContainerEl.classList.add("aura-settings-entry-info-container");
+  const entryTitle = document.createElement("p");
+  entryTitle.classList.add("aura-settings-entry-title");
+  entryTitle.textContent = entry.name;
+  if (entry.restart) {
+    const powerIcon = document.createElement("i");
+    powerIcon.classList.add(
+      "layui-icon",
+      "layui-icon-logout",
+      "aura-settings-entry-property-icon"
+    );
+    powerIcon.setAttribute("data-bs-toggle", "tooltip");
+    powerIcon.setAttribute("data-bs-placement", "top");
+    powerIcon.setAttribute("data-bs-title", "需要重启 Electron 进程");
+    entryTitle.appendChild(powerIcon);
+  }
+  if (entry.PLSRequired) {
+    const plsIcon = document.createElement("i");
+    plsIcon.classList.add(
+      "layui-icon",
+      "layui-icon-component",
+      "aura-settings-entry-property-icon"
+    );
+    plsIcon.setAttribute("data-bs-toggle", "tooltip");
+    plsIcon.setAttribute("data-bs-placement", "top");
+    plsIcon.setAttribute("data-bs-title", "需要 PLS 支持");
+    entryTitle.appendChild(plsIcon);
+  }
+  if (entry.restartPLS) {
+    const plsIcon = document.createElement("i");
+    plsIcon.classList.add(
+      "layui-icon",
+      "layui-icon-logout",
+      "aura-settings-entry-property-icon"
+    );
+    plsIcon.setAttribute("data-bs-toggle", "tooltip");
+    plsIcon.setAttribute("data-bs-placement", "top");
+    plsIcon.setAttribute("data-bs-title", "需要重启 PLS 进程");
+    entryTitle.appendChild(plsIcon);
+  }
+  if (entry.reload) {
+    const reloadIcon = document.createElement("i");
+    reloadIcon.classList.add(
+      "layui-icon",
+      "layui-icon-refresh",
+      "aura-settings-entry-property-icon"
+    );
+    reloadIcon.setAttribute("data-bs-toggle", "tooltip");
+    reloadIcon.setAttribute("data-bs-placement", "top");
+    reloadIcon.setAttribute("data-bs-title", "需要重载页面");
+    entryTitle.appendChild(reloadIcon);
+  }
+
+  const createToolTipIcon = (type, content) => {
+    const tipIcon = document.createElement("i");
+    tipIcon.classList.add(
+      "layui-icon",
+      "layui-icon-tips",
+      "aura-settings-entry-property-icon"
+    );
+    if (type === "warning") {
+      tipIcon.classList.add("aura-settings-entry-warning-icon");
+    }
+    tipIcon.setAttribute("data-bs-toggle", "tooltip");
+    tipIcon.setAttribute("data-bs-placement", "top");
+    tipIcon.setAttribute("data-bs-title", content);
+    entryTitle.appendChild(tipIcon);
+  };
+
+  if (entry.tip) {
+    createToolTipIcon("tip", entry.tipTitle);
+  }
+
+  if (entry.warning) {
+    createToolTipIcon("warning", entry.warningContent);
+  }
+
+  const entryDescription = document.createElement("p");
+  entryDescription.classList.add("aura-settings-entry-desc");
+  entryDescription.innerHTML = entry.description;
+  entryInfoContainerEl.appendChild(entryTitle);
+  entryInfoContainerEl.appendChild(entryDescription);
+
+  entryContainerEl.appendChild(entryInfoContainerEl);
+
+  const entryOperationArea = document.createElement("div");
+  entryOperationArea.classList.add("aura-settings-entry-operation-area");
+
+  let targetEl = renderInputArea(entry, entryOperationArea, entryDescription);
+  insertOrRemoveEl(entryOperationArea, targetEl, true);
+
+  if (entry.reactive) {
+    const evtListener = (event) => {
+      if (entry.reactiveVal.includes(event.detail.path.join("."))) {
+        insertOrRemoveEl(entryOperationArea, targetEl, false);
+        targetEl = renderInputArea(entry, entryOperationArea, entryDescription);
+        insertOrRemoveEl(entryOperationArea, targetEl, true);
+      }
+    };
+    const channel = entry.PLSRequired
+      ? "onPLSConfigUpdate"
+      : "onHugoAuraConfigUpdate";
+    entryContainerEl.addEventListener(channel, evtListener);
+    // createOnLeaveEvtListener(channel, evtListener);
+  }
+
+  const setDisableStatus = (el, isDisable, hint = null) => {
+    if (isDisable) {
+      el.classList.add("ase-operation-area-disabled");
+      if (hint) {
+        el.setAttribute("data-bs-toggle", "tooltip");
+        el.setAttribute("data-bs-placement", "top");
+        el.setAttribute("data-bs-title", hint);
+      }
+    } else {
+      el.setAttribute("data-bs-toggle", "");
+      el.setAttribute("data-bs-placement", "");
+      el.setAttribute("data-bs-title", "");
+      el.classList.remove("ase-operation-area-disabled");
+    }
+  };
+
+  if (entry.PLSRequired) {
+    if (!global.__HUGO_AURA__.plsStats.connected) {
+      setDisableStatus(entryOperationArea, true, "连接至 PLS 以继续");
+    }
+
+    const evtListener = (event) => {
+      if (event.detail.connected) {
+        setDisableStatus(entryOperationArea, false);
+      } else {
+        setDisableStatus(entryOperationArea, true, "连接至 PLS 以继续");
+      }
+    };
+    entryContainerEl.addEventListener("onPLSStatsUpdate", evtListener);
+    // createOnLeaveEvtListener("onPLSStatsUpdate", evtListener);
+  }
+  entryContainerEl.appendChild(entryOperationArea);
+  const isShow = entry.auraIf();
+  if (!isShow) entryContainerEl.classList.add("aura-settings-entry-hidden");
+
+  if (entry.associateVal) {
+    const evtListener = (event) => {
+      if (!entry.associateVal.includes(event.detail.path.join("."))) return;
+      const cls = entryContainerEl.classList;
+      const isShow = entry.auraIf();
+      isShow
+        ? cls.remove("aura-settings-entry-hidden")
+        : cls.add("aura-settings-entry-hidden");
+    };
+    const channel = entry.PLSRequired
+      ? "onPLSConfigUpdate"
+      : "onHugoAuraConfigUpdate";
+    entryContainerEl.addEventListener(channel, evtListener);
+    // createOnLeaveEvtListener(channel, evtListener);
+  }
+
+  formEl.appendChild(entryContainerEl);
+};
+
+const renderPreviewItem = (entry, formEl) => {
+  const elementId = entry.customId ? entry.customId : `${entry.id}Container`;
+  const eventChannel = entry.listenerType;
+
+  const separateHrContainer = document.createElement("div");
+  separateHrContainer.classList.add("aura-settings-preview-area-hr-container");
+
+  const hrTitle = document.createElement("p");
+  hrTitle.textContent = "预览";
+
+  const hrElement = document.createElement("hr");
+  hrElement.classList.add("aura-settings-preview-hr");
+
+  separateHrContainer.appendChild(hrElement);
+  separateHrContainer.appendChild(hrTitle);
+  separateHrContainer.appendChild(hrElement.cloneNode());
+
+  formEl.appendChild(separateHrContainer);
+
+  const previewContainerEl = document.createElement("div");
+  previewContainerEl.classList.add("aura-settings-preview-area-container");
+  previewContainerEl.id = elementId;
+
+  const eventListener = (event) => {
+    const childs = previewContainerEl.querySelectorAll("*");
+    Array.from(childs).forEach((el) => {
+      el.dispatchEvent(
+        new CustomEvent("onAssociateValueUpdated", { detail: event.detail })
+      );
+    });
+  };
+
+  document.addEventListener(
+    eventChannel === "pls" ? "onPLSConfigUpdate" : "onHugoAuraConfigUpdate",
+    eventListener
+  );
+  createOnLeaveEvtListener(eventListener); // Clean up
+
+  formEl.appendChild(previewContainerEl);
+
+  setTimeout(() => {
+    global.__HUGO_AURA_LOADER__[entry.loaderTarget].active = true;
+  }, 50);
+};
+
+const renderChild = (entry, formEl) => {
+  switch (entry.type) {
+    case "preview":
+      renderPreviewItem(entry, formEl);
+      break;
+    default:
+      renderNormalSettingsItem(entry, formEl);
+      break;
+  }
+};
+
+const settingsRenderer = (pendingEl, settingsObj) => {
   const formEl = document.createElement("form");
   formEl.classList.add("aura-settings-form");
   for (const category of settingsObj) {
@@ -50,193 +369,7 @@ const settingsRenderer = (pendingEl, settingsObj, isPls = false) => {
     categoryTitleEl.textContent = category.categoryName;
     formEl.appendChild(categoryTitleEl);
     for (const entry of category.child) {
-      const entryContainerEl = document.createElement("div");
-      entryContainerEl.classList.add("aura-settings-entry");
-      entryContainerEl.id = `${entry.id}Container`;
-
-      const entryInfoContainerEl = document.createElement("div");
-      entryInfoContainerEl.classList.add("aura-settings-entry-info-container");
-      const entryTitle = document.createElement("p");
-      entryTitle.classList.add("aura-settings-entry-title");
-      entryTitle.textContent = entry.name;
-      if (entry.restart) {
-        const powerIcon = document.createElement("i");
-        powerIcon.classList.add(
-          "layui-icon",
-          "layui-icon-logout",
-          "aura-settings-entry-property-icon"
-        );
-        powerIcon.setAttribute("data-bs-toggle", "tooltip");
-        powerIcon.setAttribute("data-bs-placement", "top");
-        powerIcon.setAttribute("data-bs-title", "需要重启 Electron 进程");
-        entryTitle.appendChild(powerIcon);
-      }
-      if (entry.restartPLS) {
-        const plsIcon = document.createElement("i");
-        plsIcon.classList.add(
-          "layui-icon",
-          "layui-icon-logout",
-          "aura-settings-entry-property-icon"
-        );
-        plsIcon.setAttribute("data-bs-toggle", "tooltip");
-        plsIcon.setAttribute("data-bs-placement", "top");
-        plsIcon.setAttribute("data-bs-title", "需要重启 PLS 进程");
-        entryTitle.appendChild(plsIcon);
-      }
-      if (entry.reload) {
-        const reloadIcon = document.createElement("i");
-        reloadIcon.classList.add(
-          "layui-icon",
-          "layui-icon-refresh",
-          "aura-settings-entry-property-icon"
-        );
-        reloadIcon.setAttribute("data-bs-toggle", "tooltip");
-        reloadIcon.setAttribute("data-bs-placement", "top");
-        reloadIcon.setAttribute("data-bs-title", "需要重载页面");
-        entryTitle.appendChild(reloadIcon);
-      }
-
-      const createToolTipIcon = (type, content) => {
-        const tipIcon = document.createElement("i");
-        tipIcon.classList.add(
-          "layui-icon",
-          "layui-icon-tips",
-          "aura-settings-entry-property-icon"
-        );
-        if (type === "warning") {
-          tipIcon.classList.add("aura-settings-entry-warning-icon");
-        }
-        tipIcon.setAttribute("data-bs-toggle", "tooltip");
-        tipIcon.setAttribute("data-bs-placement", "top");
-        tipIcon.setAttribute("data-bs-title", content);
-        entryTitle.appendChild(tipIcon);
-      };
-
-      if (entry.tip) {
-        createToolTipIcon("tip", entry.tipTitle);
-      }
-
-      if (entry.warning) {
-        createToolTipIcon("warning", entry.warningContent);
-      }
-
-      const entryDescription = document.createElement("p");
-      entryDescription.classList.add("aura-settings-entry-desc");
-      entryDescription.textContent = entry.description;
-      entryInfoContainerEl.appendChild(entryTitle);
-      entryInfoContainerEl.appendChild(entryDescription);
-
-      entryContainerEl.appendChild(entryInfoContainerEl);
-
-      const entryOperationArea = document.createElement("div");
-      entryOperationArea.classList.add("aura-settings-entry-operation-area");
-      switch (entry.type) {
-        case "switch":
-          {
-            const switchEl = document.createElement("input");
-            switchEl.classList.add("form-check-input");
-            switchEl.type = "checkbox";
-            switchEl.role = "switch";
-            switchEl.id = entry.id;
-            const elValue = entry.valueGetter();
-            switchEl.value = elValue;
-            switchEl.checked = elValue;
-            switchEl.addEventListener("change", (event) => {
-              showToast(entry);
-              entry.callbackFn(event.target.checked);
-            });
-            entryOperationArea.classList.add("form-check", "form-switch");
-            entryOperationArea.appendChild(switchEl);
-          }
-          break;
-        case "radio":
-          {
-            const elValue = entry.valueGetter();
-            for (const template of entry.templates) {
-              const inlineContainerEl = document.createElement("div");
-              inlineContainerEl.classList.add(
-                "form-check",
-                "form-check-inline"
-              );
-              const radioEl = document.createElement("input");
-              radioEl.value = template;
-              radioEl.classList.add("form-check-input");
-              radioEl.type = "radio";
-              radioEl.name = `${entry.id}Radios`;
-              radioEl.id = `${entry.id}Radio${entry.templates.indexOf(
-                template
-              )}`;
-              radioEl.checked = template === elValue ? true : false;
-              radioEl.addEventListener("change", (event) => {
-                if (event.target.checked) {
-                  showToast(entry);
-                  entry.callbackFn(event.target.value);
-                }
-              });
-              inlineContainerEl.appendChild(radioEl);
-              const labelEl = document.createElement("label");
-              labelEl.classList.add("form-check-label");
-              labelEl.setAttribute("for", radioEl.id);
-              labelEl.textContent =
-                entry.templateLabels[entry.templates.indexOf(template)];
-              inlineContainerEl.appendChild(labelEl);
-              entryOperationArea.appendChild(inlineContainerEl);
-            }
-          }
-          break;
-        case "input":
-          {
-            const inputEl = document.createElement("input");
-            inputEl.classList.add("form-control");
-            inputEl.type = entry.subType;
-            inputEl.value = entry.valueGetter();
-            inputEl.placeholder = entry.placeHolder;
-            inputEl.id = entry.id;
-            inputEl.addEventListener("change", (event) => {
-              const result = entry.callbackFn(event.target.value);
-              const success = result.valid;
-              if (success) {
-                showToast(entry);
-
-                if (inputEl.className.includes("is-invalid")) {
-                  inputEl.classList.remove("is-invalid");
-                  entryDescription.textContent = entry.description;
-                  entryDescription.classList.remove("ase-desc-error-hint");
-                }
-              } else {
-                inputEl.classList.add("is-invalid");
-                entryDescription.textContent = result.hint;
-                entryDescription.classList.add("ase-desc-error-hint");
-              }
-            });
-            entryOperationArea.classList.add("ase-operation-area-expanded");
-            entryOperationArea.appendChild(inputEl);
-          }
-          break;
-        default:
-          break;
-      }
-
-      entryContainerEl.appendChild(entryOperationArea);
-      const isShow = entry.auraIf();
-      if (!isShow) entryContainerEl.classList.add("aura-settings-entry-hidden");
-
-      if (entry.associateVal) {
-        document.addEventListener(
-          isPls ? "onPLSConfigUpdate" : "onHugoAuraConfigUpdate",
-          (event) => {
-            if (!entry.associateVal.includes(event.detail.path.join(".")))
-              return;
-            const cls = entryContainerEl.classList;
-            const isShow = entry.auraIf();
-            isShow
-              ? cls.remove("aura-settings-entry-hidden")
-              : cls.add("aura-settings-entry-hidden");
-          }
-        );
-      }
-
-      formEl.appendChild(entryContainerEl);
+      renderChild(entry, formEl);
     }
 
     const hrEl = document.createElement("hr");
@@ -245,12 +378,7 @@ const settingsRenderer = (pendingEl, settingsObj, isPls = false) => {
   }
   pendingEl.appendChild(formEl);
 
-  const tooltipTriggerList = document.querySelectorAll(
-    '[data-bs-toggle="tooltip"]'
-  );
-  [...tooltipTriggerList].map(
-    (tooltipTriggerEl) => new bootstrap.Tooltip(tooltipTriggerEl)
-  );
+  global.__HUGO_AURA_GLOBAL__.utils.refreshBsTooltip();
 };
 
 module.exports = { settingsRenderer };

src/aura/ui/css/form.css

@@ -46,6 +46,15 @@
   flex: 0.75;
 }
 
+.aura-settings-entry-operation-area.ase-operation-area-disabled {
+  opacity: 0.25;
+  cursor: not-allowed;
+}
+
+.aura-settings-entry-operation-area.ase-operation-area-disabled * {
+  pointer-events: none;
+}
+
 .aura-settings-entry-operation-area.form-switch {
   transform: scale(1.2);
 }
@@ -56,6 +65,33 @@
   border-bottom: 0.75px solid rgba(0, 0, 0, 0.25);
 }
 
+.aura-settings-preview-area-hr-container {
+  display: flex;
+  flex-direction: row;
+  align-items: center;
+  justify-content: center;
+}
+
+.aura-settings-preview-hr {
+  margin-top: 1.5rem;
+  margin-bottom: 1.5rem;
+  border-bottom: 0.75px solid rgba(0, 0, 0, 0.25);
+  width: -webkit-fill-available;
+}
+
+.aura-settings-preview-area-hr-container p {
+  margin-left: 0.5rem;
+  margin-right: 0.5rem;
+  min-width: 2rem;
+  opacity: 0.75;
+  text-align: center;
+}
+
+.aura-settings-preview-area-container {
+  width: 100%;
+  padding-bottom: 0.5rem;
+}
+
 .aura-settings-entry-property-icon {
   margin-left: 0.5rem;
   font-size: 15px;
@@ -72,7 +108,7 @@
 .aura-settings-entry-warning-icon {
   transform: rotate(180deg);
   display: inline-block;
-  color: rgb(241, 155, 0);
+  color: rgb(147, 0, 0);
 }
 
 /* Animations */

src/aura/ui/css/global.css

@@ -25,3 +25,7 @@ button.nav-link {
 .nav-underline {
   --bs-nav-underline-link-active-color: #0d6efd !important;
 }
+
+.tooltip {
+  --bs-tooltip-max-width: 400px !important;
+}

src/aura/ui/hookDefinitions/assistant.js

@@ -21,41 +21,60 @@ const def = {
       pageSelector: "#root",
       selectorMode: "appendChild",
       pageCSS: "ui/pages/config/config.css",
-    },
-    "Aura.UI.Assistant.Config.DisableLimitations": {
-      active: false,
-      pageURI:
-        "ui/pages/configSubPages/disableLimitations/disableLimitations.html",
-      pageScript:
-        "ui/pages/configSubPages/disableLimitations/disableLimitations.js",
-      pageSelector: ".aura-config-page-subpage-container",
-      selectorMode: "appendChild",
-      pageCSS:
-        "ui/pages/configSubPages/disableLimitations/disableLimitations.css",
-    },
-    "Aura.UI.Assistant.Config.BehaviourCtrl": {
-      active: false,
-      pageURI: "ui/pages/configSubPages/behaviourCtrl/behaviourCtrl.html",
-      pageScript: "ui/pages/configSubPages/behaviourCtrl/behaviourCtrl.js",
-      pageSelector: ".aura-config-page-subpage-container",
-      selectorMode: "appendChild",
-      pageCSS: "ui/pages/configSubPages/behaviourCtrl/behaviourCtrl.css",
-    },
-    "Aura.UI.Assistant.Config.BehaviourCtrl.PlsStatus": {
-      active: false,
-      pageURI: "ui/pages/configSubPages/behaviourCtrl/plsStatus.html",
-      pageScript: "ui/pages/configSubPages/behaviourCtrl/plsStatus.js",
-      pageSelector: "#status-subpage",
-      selectorMode: "appendChild",
-      pageCSS: "ui/pages/configSubPages/behaviourCtrl/plsStatus.css",
-    },
-    "Aura.UI.Assistant.Config.Preferences": {
-      active: false,
-      pageURI: "ui/pages/configSubPages/preferences/preferences.html",
-      pageScript: "ui/pages/configSubPages/preferences/preferences.js",
-      pageSelector: ".aura-config-page-subpage-container",
-      selectorMode: "appendChild",
-      pageCSS: "ui/pages/configSubPages/preferences/preferences.css",
+      childs: {
+        DisableLimitations: {
+          active: false,
+          pageURI:
+            "ui/pages/configSubPages/disableLimitations/disableLimitations.html",
+          pageScript:
+            "ui/pages/configSubPages/disableLimitations/disableLimitations.js",
+          pageSelector: ".aura-config-page-subpage-container",
+          selectorMode: "appendChild",
+          pageCSS:
+            "ui/pages/configSubPages/disableLimitations/disableLimitations.css",
+        },
+        BehaviourCtrl: {
+          active: false,
+          pageURI: "ui/pages/configSubPages/behaviourCtrl/behaviourCtrl.html",
+          pageScript: "ui/pages/configSubPages/behaviourCtrl/behaviourCtrl.js",
+          pageSelector: ".aura-config-page-subpage-container",
+          selectorMode: "appendChild",
+          pageCSS: "ui/pages/configSubPages/behaviourCtrl/behaviourCtrl.css",
+          childs: {
+            PlsStatus: {
+              active: false,
+              pageURI: "ui/pages/configSubPages/behaviourCtrl/plsStatus.html",
+              pageScript: "ui/pages/configSubPages/behaviourCtrl/plsStatus.js",
+              pageSelector: "#status-subpage",
+              selectorMode: "appendChild",
+              pageCSS: "ui/pages/configSubPages/behaviourCtrl/plsStatus.css",
+            },
+            DeviceSecurity: {
+              childs: {
+                FreezeOverridePreview: {
+                  active: false,
+                  pageURI:
+                    "ui/pages/configSubPages/behaviourCtrl/settings/previews/freezeOverridePreview/freezeOverridePreview.html",
+                  pageScript:
+                    "ui/pages/configSubPages/behaviourCtrl/settings/previews/freezeOverridePreview/freezeOverridePreview.js",
+                  pageSelector: "#freezeInfoReportOverridePreviewContainer",
+                  selectorMode: "appendChild",
+                  pageCSS:
+                    "ui/pages/configSubPages/behaviourCtrl/settings/previews/freezeOverridePreview/freezeOverridePreview.css",
+                },
+              },
+            },
+          },
+        },
+        Preferences: {
+          active: false,
+          pageURI: "ui/pages/configSubPages/preferences/preferences.html",
+          pageScript: "ui/pages/configSubPages/preferences/preferences.js",
+          pageSelector: ".aura-config-page-subpage-container",
+          selectorMode: "appendChild",
+          pageCSS: "ui/pages/configSubPages/preferences/preferences.css",
+        },
+      },
     },
   },
   globalStyles: [
@@ -65,7 +84,11 @@ const def = {
     "ui/layui/css/layui.css",
     "ui/bootstrap/bootstrap.min.css",
   ],
-  globalJS: ["ui/js/global.js", "ui/bootstrap/bootstrap.bundle.min.js"],
+  globalJS: [
+    "ui/js/global.js",
+    "ui/js/plsListener.js",
+    "ui/bootstrap/bootstrap.bundle.min.js",
+  ],
   onLoaded: `
     console.log('[HugoAura / UI / Hooks / Assistant] Page loaded.');
   `,

src/aura/ui/js/global.js

@@ -1,9 +1,43 @@
 (() => {
+  /* Util: Sleep */
   const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
+  /* Util: BootStrap Tooltip Ctrl */
+  let tooltipTriggerCache = null;
+  const refreshBsTooltip = () => {
+    if (tooltipTriggerCache) {
+      [...tooltipTriggerCache].map((el) =>
+        bootstrap.Tooltip.getInstance(el).disable()
+      );
+    }
+
+    const tooltipTriggerList = document.querySelectorAll(
+      '[data-bs-toggle="tooltip"]'
+    );
+    tooltipTriggerCache = tooltipTriggerList;
+    [...tooltipTriggerList].map(
+      (tooltipTriggerEl) => new bootstrap.Tooltip(tooltipTriggerEl)
+    );
+  };
+
+  const createOnLeaveEvtListener = (
+    channel,
+    pendingRmEvtListener,
+    leaveEvt = "onCurConfigPageLeave"
+  ) => {
+    const rmEvtListener = (event) => {
+      document.removeEventListener(channel, pendingRmEvtListener);
+      document.removeEventListener(leaveEvt, rmEvtListener);
+    };
+    document.addEventListener(leaveEvt, rmEvtListener);
+    return rmEvtListener;
+  };
+
   if (!window.__HUGO_AURA_GLOBAL__) window.__HUGO_AURA_GLOBAL__ = {};
 
   window.__HUGO_AURA_GLOBAL__.utils = {
     sleep,
+    refreshBsTooltip,
+    createOnLeaveEvtListener,
   };
 })();

src/aura/ui/js/plsConnectionManager.js

@@ -1,192 +1,332 @@
 // @ts-check
-
-const IPC_METHOD_BASE = "$aura.pls";
-const REQUIRE_BASE = "../../aura/ui";
-const __SCOPE = "desktopAssistant";
-
-const { pushMsgHandler } = require(`${REQUIRE_BASE}/pls/pushHandler`);
-
-/** @type {number} */
-let failedCounter = 0;
-/** @type {boolean} */
-let isErrorOccurred = false;
-
-/**
- *
- * @param {string} authToken
- * @param {any} callback
- * @returns
- */
-const createPlsConnection = (authToken, callback) => {
-  if (failedCounter >= 3) {
-    console.error(
-      `[HugoAura / UI / PLS Manager / ERROR] Failed connecting to PLS WebSocket server, please check the status of PLS process.`
-    );
-    return;
-  }
-
-  /** @type {WebSocket} */
-  const plsWs = new WebSocket(
-    `wss://pls.hugoaura.local:22077/?auth=${authToken}`
-  );
-
-  plsWs.onopen = () => {
-    callback(true, plsWs);
-  };
-
-  plsWs.onerror = () => {
-    isErrorOccurred = true;
-    failedCounter += 1;
-    callback(false, plsWs);
-  };
-
-  plsWs.onclose = () => {
-    console.error(
-      "[HugoAura / UI / PLS Manager / ERROR] WebSocket connection closed."
-    );
-    if (isErrorOccurred) return;
-    failedCounter += 1;
-    callback(false, plsWs);
-  };
-};
-
-/**
- *
- * @param {WebSocket} wsObj
- */
-const registerSendReqListener = (wsObj) => {
-  global.ipcRenderer.on(
-    `${IPC_METHOD_BASE}.ws.post.onReqSendMsg`,
-    /**
-     *
-     * @param {Event} _evt
-     * @param {any} arg
-     */
-    (_evt, arg) => {
-      wsObj.send(JSON.stringify(arg));
-    }
-  );
-};
-
-/**
- *
- * @param {boolean} result
- * @param {WebSocket} wsObj
- * @returns
- */
-const connectionResultCallback = (result, wsObj) => {
-  global.__HUGO_AURA_GLOBAL__.plsStats.launched = result;
-  global.__HUGO_AURA_GLOBAL__.plsStats.connected = result;
-  global.ipcRenderer.invoke(
-    `${IPC_METHOD_BASE}.updatePlsStats`,
-    global.__HUGO_AURA_GLOBAL__.plsStats
-  );
-  if (!result) {
-    console.error(
-      `[HugoAura / UI / PLS Manager / ERROR] Failed connecting to PLS WebSocket server, retrying ...`
-    );
-    createPlsConnection(
-      global.__HUGO_AURA_GLOBAL__.plsStats.authToken,
-      connectionResultCallback
-    );
-    return;
-  }
-  global.__HUGO_AURA_GLOBAL__.plsWs = wsObj;
-  registerSendReqListener(wsObj);
-  wsObj.onmessage = plsPushHandler;
-};
-
-/**
- *
- * @param {MessageEvent} event
- */
-const plsPushHandler = (event) => {
-  try {
-    /** @type {Record<any, any>} */
-    const parsedEvent = JSON.parse(event.data);
-    console.debug(
-      "[HugoAura / UI / PLS Manager / DEBUG] Received new server message: "
-    );
-    if (!parsedEvent.eventId) {
-      // Push
-      pushMsgHandler(parsedEvent);
-    } else {
-      // Not push
-      global.ipcRenderer.send(
-        `${IPC_METHOD_BASE}.ws.broadcastMessageRecv`,
-        parsedEvent
-      );
-    }
-  } catch {
-    console.error(
-      "[HugoAura / UI / PLS Manager / ERROR] Failed to resolve server message: ",
-      event.data
-    );
-  }
-};
-
-const initPlsConnection = async () => {
-  failedCounter = 0;
-  isErrorOccurred = false;
-
-  const curPlsStats = await global.ipcRenderer.invoke(
-    `${IPC_METHOD_BASE}.getPlsStats`
-  );
-  let updatedPlsStats = {};
-  if (curPlsStats === null || !curPlsStats.success) {
-    updatedPlsStats = {
+(() => {
+  if (!global.__HUGO_AURA__.plsStats)
+    global.__HUGO_AURA__.plsStats = {
       installed: false,
-      launched: false,
       detached: false,
       connected: false,
-      version: "未知",
+      launched: false,
       status: "dead",
-      authToken: "66ccff0d000721114514191981023333",
+      version: "未知",
+      authToken: "",
     };
-  } else {
-    updatedPlsStats = curPlsStats.data;
-  }
 
-  const isPlsFolderExists = (
-    await global.ipcRenderer.invoke(`${IPC_METHOD_BASE}.getPlsFolderExists`)
-  ).data.isExists;
-  updatedPlsStats.installed = isPlsFolderExists;
+  const IPC_METHOD_BASE = "$aura.pls";
+  const REQUIRE_BASE = "../../aura/ui";
+  const __SCOPE = "desktopAssistant";
 
-  global.__HUGO_AURA_GLOBAL__.plsStats = updatedPlsStats;
-  console.debug(
-    "[HugoAura / UI / PLS Manager / DEBUG] Updated plsStats:",
-    global.__HUGO_AURA_GLOBAL__.plsStats
-  );
+  const PLS_REG_PATH = "ProxyLayerServices";
 
-  global.ipcRenderer.invoke(
-    `${IPC_METHOD_BASE}.updatePlsStats`,
-    updatedPlsStats
-  );
+  const { pushMsgHandler } = require(`${REQUIRE_BASE}/pls/pushHandler`);
+  const RegistryManager = require(`${REQUIRE_BASE}/../init/shared/registryManager`);
 
-  const startConnPls = () => {
+  const registryManager = new RegistryManager();
+
+  /** @type {number} */
+  let failedCounter = 0;
+  /** @type {boolean} */
+  let isErrorOccurred = false;
+
+  /** @type {number} */
+  let plsPort = 22077;
+  /** @type {"wss" | "ws"} */
+  let plsProtocol = "wss";
+
+  /** @type {boolean} */
+  let isRetrying = false;
+
+  /** @type {any} */
+  let curSendListener = null;
+
+  const sendRetryStatusToMain = (/** @type {Boolean} */ status) => {
+    global.ipcRenderer.invoke(`${IPC_METHOD_BASE}.post.updateRetryStatus`, {
+      success: status,
+    });
+  };
+
+  const calcFullAuthToken = (/** @type {string} */ authToken) => {
+    const trustToken = window._ACCEPT_DATA.getData("deviceId");
+    const conjToken = authToken + "AuraXAuth" + trustToken + "NeverEnds";
+    const crypto = require("crypto");
+    return crypto.createHash("sha512").update(conjToken).digest("hex");
+  };
+
+  const clearIpcListener = () => {
+    if (curSendListener) {
+      global.ipcRenderer.off(
+        `${IPC_METHOD_BASE}.ws.post.onReqSendMsg`,
+        curSendListener
+      );
+      curSendListener = null;
+    }
+  };
+
+  const startConnPlsProc = async (updatedPlsStats) => {
+    const authTokenRet = await registryManager.readRegKey(
+      PLS_REG_PATH,
+      "AuthToken",
+      true
+    );
+    if (authTokenRet.success) {
+      updatedPlsStats.authToken = authTokenRet.data;
+      // @ts-expect-error
+      global.__HUGO_AURA__.plsStats.authToken = authTokenRet.data;
+    } else {
+      sendRetryStatusToMain(false);
+      return;
+    }
+    const portRet = await registryManager.readRegKey(
+      PLS_REG_PATH,
+      "WsPort",
+      true
+    );
+    if (portRet.success) {
+      try {
+        plsPort = Number(portRet.data);
+      } catch {
+        console.warn(
+          `[HugoAura / UI / PLS Manager] Invalid PLS port: ${portRet.data}`
+        );
+      }
+    }
+    const protoRet = await registryManager.readRegKey(
+      PLS_REG_PATH,
+      "Protocol",
+      true
+    );
+    if (protoRet.success) {
+      plsProtocol = protoRet.data;
+    }
     createPlsConnection(updatedPlsStats.authToken, connectionResultCallback);
   };
 
-  if (updatedPlsStats.detached && updatedPlsStats.installed) {
-    startConnPls();
-  }
+  /**
+   *
+   * @param {string} authToken
+   * @param {any} callback
+   * @returns
+   */
+  const createPlsConnection = (authToken, callback) => {
+    if (failedCounter >= 3) {
+      console.error(
+        `[HugoAura / UI / PLS Manager / ERROR] Failed connecting to PLS WebSocket server, please check the status of PLS process.`
+      );
+      sendRetryStatusToMain(false);
+      return;
+    }
 
-  global.ipcRenderer.on(`${IPC_METHOD_BASE}.post.onPlsLaunched`, (_event) => {
-    setTimeout(() => {
-      startConnPls();
-    }, 5000);
-  });
-};
+    const fullAuthToken = calcFullAuthToken(authToken);
 
-const onSetup = () => {
-  if (!global.global.ipcRenderer) {
-    // @ts-ignore
-    global.global.ipcRenderer = require("electron").global.ipcRenderer;
-  }
+    /** @type {WebSocket} */
+    const plsWs = new WebSocket(
+      `${plsProtocol}://pls.hugoaura.local:${plsPort}/?auth=${fullAuthToken}`
+    );
 
-  initPlsConnection();
-};
+    plsWs.onopen = () => {
+      callback(true, plsWs);
+    };
+
+    plsWs.onerror = () => {
+      isErrorOccurred = true;
+      failedCounter += 1;
+      callback(false, plsWs);
+    };
+
+    plsWs.onclose = () => {
+      clearIpcListener();
+      if (global.__HUGO_AURA__.plsStats) {
+        if (global.__HUGO_AURA__.plsStats.status === "notReady") {
+          if (isRetrying) {
+            sendRetryStatusToMain(false);
+            return;
+          }
+          console.warn(
+            "[HugoAura / UI / PLS Manager / WARN] PLS not ready, try again after 10s..."
+          );
+          isRetrying = true;
+          setTimeout(async () => {
+            isRetrying = false;
+            startConnPlsProc(global.__HUGO_AURA__.plsStats);
+          }, 10000);
+          sendRetryStatusToMain(false);
+          return;
+        }
+      }
+
+      console.error(
+        "[HugoAura / UI / PLS Manager / ERROR] WebSocket connection closed."
+      );
+      if (isErrorOccurred) return;
+      failedCounter += 1;
+      callback(false, plsWs);
+    };
+  };
+
+  /**
+   *
+   * @param {WebSocket} wsObj
+   */
+  const registerSendReqListener = (wsObj) => {
+    clearIpcListener();
+    /**
+     *
+     * @param {import("electron").IpcRendererEvent} _evt
+     * @param {any} arg
+     */
+    curSendListener = (_evt, arg) => {
+      wsObj.send(JSON.stringify(arg));
+    };
+    global.ipcRenderer.on(
+      `${IPC_METHOD_BASE}.ws.post.onReqSendMsg`,
+      curSendListener
+    );
+  };
+
+  /**
+   *
+   * @param {boolean} result
+   * @param {WebSocket} wsObj
+   * @returns
+   */
+  const connectionResultCallback = (result, wsObj) => {
+    if (!global.__HUGO_AURA__.plsStats) return; // 😅 typescript
+
+    global.__HUGO_AURA__.plsStats.launched = result;
+    global.__HUGO_AURA__.plsStats.connected = result;
+    global.ipcRenderer.invoke(
+      `${IPC_METHOD_BASE}.updatePlsStats`,
+      global.__HUGO_AURA__.plsStats
+    );
+    if (!result) {
+      console.error(
+        `[HugoAura / UI / PLS Manager / ERROR] Failed connecting to PLS WebSocket server, retrying ...`
+      );
+      createPlsConnection(
+        global.__HUGO_AURA__.plsStats.authToken,
+        connectionResultCallback
+      );
+      return;
+    }
+
+    sendRetryStatusToMain(true);
+
+    global.__HUGO_AURA__.plsWs = wsObj;
+    registerSendReqListener(wsObj);
+    wsObj.onmessage = plsPushHandler;
+  };
+
+  /**
+   *
+   * @param {MessageEvent} event
+   */
+  const plsPushHandler = (event) => {
+    try {
+      /** @type {Record<any, any>} */
+      const parsedEvent = JSON.parse(event.data);
+      console.debug(
+        "[HugoAura / UI / PLS Manager / DEBUG] Received new server message: "
+      );
+      if (!parsedEvent.eventId) {
+        // Push
+        pushMsgHandler(parsedEvent);
+      } else {
+        // Not push
+        global.ipcRenderer.send(
+          `${IPC_METHOD_BASE}.ws.broadcastMessageRecv`,
+          parsedEvent
+        );
+      }
+    } catch {
+      console.error(
+        "[HugoAura / UI / PLS Manager / ERROR] Failed to resolve server message: ",
+        event.data
+      );
+    }
+  };
+
+  const initPlsConnection = async () => {
+    if (!global.__HUGO_AURA__.plsStats) return;
+
+    if (isRetrying) {
+      sendRetryStatusToMain(false);
+      return;
+    }
+
+    failedCounter = 0;
+    isErrorOccurred = false;
+
+    const curPlsStats = await global.ipcRenderer.invoke(
+      `${IPC_METHOD_BASE}.getPlsStats`
+    );
+    let updatedPlsStats = {};
+    if (
+      (curPlsStats === null || !curPlsStats.success) &&
+      curPlsStats.status !== "downloading"
+    ) {
+      updatedPlsStats = {
+        installed: false,
+        launched: false,
+        detached: false,
+        connected: false,
+        version: "未知",
+        status: "dead",
+        authToken: "66ccff0d000721114514191981023333",
+      };
+      const isPlsFolderExists = (
+        await global.ipcRenderer.invoke(`${IPC_METHOD_BASE}.getPlsBinExists`)
+      ).data.isExists;
+      updatedPlsStats.installed = isPlsFolderExists;
+    } else {
+      updatedPlsStats = curPlsStats.data;
+    }
+
+    // @ts-expect-error
+    global.__HUGO_AURA__.plsStats = updatedPlsStats;
+    console.debug(
+      "[HugoAura / UI / PLS Manager / DEBUG] Updated early plsStats:",
+      global.__HUGO_AURA__.plsStats
+    );
+
+    global.ipcRenderer.invoke(
+      `${IPC_METHOD_BASE}.updatePlsStats`,
+      updatedPlsStats
+    );
+
+    /*
+    if (updatedPlsStats.detached && updatedPlsStats.installed) {
+    */
+    if (updatedPlsStats.installed) {
+      await startConnPlsProc(updatedPlsStats);
+    } else {
+      sendRetryStatusToMain(false);
+    }
+
+    /*
+    global.ipcRenderer.on(`${IPC_METHOD_BASE}.post.onPlsLaunched`, (_event) => {
+      setTimeout(() => {
+        startConnPls();
+      }, 5000);
+    });
+    */
+  };
+
+  const onSetup = () => {
+    if (!global.ipcRenderer) {
+      // @ts-ignore
+      global.ipcRenderer = require("electron").global.ipcRenderer;
+    }
+
+    initPlsConnection();
+
+    global.ipcRenderer.on(
+      `${IPC_METHOD_BASE}.retryPlsConnect`,
+      (_evt, _arg) => {
+        if (!global.__HUGO_AURA__.plsStats) return;
+        if (global.__HUGO_AURA__.plsStats.connected) return;
+        initPlsConnection();
+      }
+    );
+  };
 
-(() => {
   onSetup();
 })();

src/aura/ui/js/plsListener.js

@@ -0,0 +1,112 @@
+(() => {
+  const IPC_METHOD_BASE = "$aura.pls";
+  const REQUIRE_BASE = "../../aura/ui";
+  const __SCOPE = "assistant";
+  const {
+    updatePlsStatusFromLocal,
+  } = require(`${REQUIRE_BASE}/composables/plsConfigManager`);
+
+  const setupListeners = () => {
+    if (!global.ipcRenderer)
+      global.ipcRenderer = require("electron").ipcRenderer;
+
+    ipcRenderer.on(
+      `${IPC_METHOD_BASE}.post.onPlsStatsUpdate`,
+      (_event, arg) => {
+        global.__HUGO_AURA__.plsStats = arg;
+
+        const event = new CustomEvent("onPLSStatsUpdate", {
+          detail: {
+            connected: arg.connected,
+          },
+        });
+
+        document.dispatchEvent(event);
+
+        const settingsEntries = document.getElementsByClassName(
+          "aura-settings-entry"
+        );
+        if (settingsEntries.length > 0) {
+          Array.from(settingsEntries).forEach((entry) => {
+            entry.dispatchEvent(event);
+          });
+        }
+      }
+    );
+
+    ipcRenderer.on(
+      `${IPC_METHOD_BASE}.post.onPlsSettingsUpdate`,
+      (_event, arg) => {
+        global.__HUGO_AURA__.plsSettings = arg;
+
+        const event = new CustomEvent("onPLSConfigUpdate", {
+          detail: {
+            path: ["root", "settings"],
+            value: arg,
+          },
+        });
+
+        document.dispatchEvent(event);
+
+        const settingsEntries = document.getElementsByClassName(
+          "aura-settings-entry"
+        );
+        if (settingsEntries.length > 0) {
+          Array.from(settingsEntries).forEach((entry) => {
+            entry.dispatchEvent(event);
+          });
+        }
+      }
+    );
+
+    ipcRenderer.on(
+      `${IPC_METHOD_BASE}.post.onPlsRulesUpdate`,
+      (_event, arg) => {
+        global.__HUGO_AURA__.plsRules = arg;
+
+        const event = new CustomEvent("onPLSConfigUpdate", {
+          detail: {
+            path: ["root", "ruleSettings"],
+            value: arg,
+          },
+        });
+
+        document.dispatchEvent(event);
+
+        const settingsEntries = document.getElementsByClassName(
+          "aura-settings-entry"
+        );
+        if (settingsEntries.length > 0) {
+          Array.from(settingsEntries).forEach((entry) => {
+            entry.dispatchEvent(event);
+          });
+        }
+      }
+    );
+
+    ipcRenderer.on(
+      `${IPC_METHOD_BASE}.post.updateRetryStatus`,
+      (_event, arg) => {
+        const event = new CustomEvent("onPLSStatsUpdate", {
+          detail: {
+            connected: arg.success,
+          },
+        });
+
+        document.dispatchEvent(event);
+
+        if (
+          global.__HUGO_AURA_LOADER__["Aura.UI.Assistant.Config.BehaviourCtrl"]
+            .active
+        ) {
+          setTimeout(() => {
+            global.__HUGO_AURA_GLOBAL__.utils.refreshBsTooltip();
+          }, 500);
+        }
+      }
+    );
+  };
+
+  updatePlsStatusFromLocal();
+  setupListeners();
+})();

src/aura/ui/pages/config/config.css

@@ -1,486 +1,27 @@
 /* General */
 
-#aura-container-Aura-UI-Assistant-Config {
-  position: absolute;
-  top: 0;
-  left: 0;
-  height: 100%;
-  width: 100%;
-  z-index: 1000;
-}
-
-.aura-config-page-root {
-  position: absolute;
-  top: 0;
-  left: 0;
-  height: 100%;
-  width: 100%;
-  background: url("../../../../app.asar/public/ae247697b4639c92bd008d0ea7d13b53.png");
-  /* 这里不用 background-size: cover; 的效果反而更舒服一些... */
-
-  display: flex;
-  flex-direction: column;
-  align-items: center;
-  justify-content: center;
-
-  opacity: 1;
-  transform: scale(1);
-
-  transition: all 0.5s;
-}
-
-.aura-config-page-root-inactive {
-  opacity: 0;
-  transform: scale(1.5);
-}
+@import url("./css/general.css");
 
 /* Header */
 
-.aura-config-page-header-area {
-  flex: 1;
-  display: flex;
-  flex-direction: row;
-  justify-content: flex-start;
-  width: 100%;
-  padding-left: 8px;
-  padding-right: 8px;
-  color: white;
-  z-index: 12000;
-
-  opacity: 1;
-  transform: translateY(0);
-
-  transition: all 0.5s;
-}
-
-.aura-config-page-header-area .iconfont {
-  font-size: 24px;
-
-  transition: all 0.25s;
-}
-
-.aura-config-page-header-area .iconfont:hover {
-  opacity: 0.75;
-  cursor: pointer;
-}
-
-.aura-config-page-header-area .iconfont:active {
-  opacity: 0.375;
-}
-
-.aura-config-page-header-area p {
-  margin-top: -2px;
-}
-
-.aura-config-page-header-area.header-collapsed {
-  transform: translateY(-1rem);
-  opacity: 0;
-}
-
-.aura-config-page-app-bar {
-  height: 40px;
-  display: flex;
-  justify-content: flex-start;
-  align-items: center;
-  width: 100%;
-}
+@import url("./css/header.css");
 
 /* Status */
 
-.aura-config-page-status-container {
-  flex: 1;
-  width: 100%;
-  align-self: center;
-  display: flex;
-  flex-direction: column;
-  justify-content: center;
-  align-items: center;
-
-  opacity: 1;
-
-  transition: all 0.5s;
-}
-
-.aura-config-page-status-container-hidden {
-  position: absolute;
-  opacity: 0;
-}
-
-.aura-config-page-status-main,
-.aura-config-page-status-description {
-  width: 100%;
-  display: flex;
-  flex-direction: row;
-  justify-content: center;
-  align-items: center;
-}
-
-.aura-config-page-status-description {
-  margin-top: 0.5rem;
-  transform: translateY(0);
-  opacity: 1;
-
-  transition: all 0.5s;
-}
-
-.aura-config-page-status-description.status-description-hidden {
-  transform: translateY(-2rem);
-  opacity: 0;
-}
-
-.aura-config-page-status-description p {
-  font-size: 18px;
-  margin-left: 15px;
-  margin-top: -2px;
-  color: white;
-  font-family: "Consolas", "Microsoft YaHei", sans-serif;
-}
-
-.aura-config-page-status-description i {
-  color: white;
-}
-
-.aura-config-page-central-aura-logo {
-  margin: 0.5rem 3rem;
-  width: 17.5%;
-}
-
-.aura-config-hr-vertical {
-  height: 3.75rem;
-  width: 1px;
-  background-color: rgba(255, 255, 255, 0.3);
-  margin-left: 30px;
-  margin-right: 30px;
-  border: none;
-}
-
-.aura-config-page-status-el {
-  display: flex;
-  flex-direction: column;
-  align-items: center;
-  justify-content: center;
-  font-family: "Consolas", monospace;
-  color: white;
-
-  /*
-  .version-type {
-    content: "I want to use scss plz 😇"
-  }
-  */
-}
-
-.aura-config-page-status-side {
-  height: 30%;
-  display: flex;
-  flex-direction: row;
-  align-items: center;
-  flex: 1;
-
-  transform: translateX(0);
-  opacity: 1;
-
-  transition: transform 0.5s, opacity 0.5s;
-}
-
-.aura-config-page-status-side.left-side {
-  justify-content: flex-end;
-}
-
-.aura-config-page-status-side.left-side.status-side-hidden {
-  transform: translateX(5rem);
-  opacity: 0;
-}
-
-.aura-config-page-status-side.right-side {
-  justify-content: flex-start;
-}
-
-.aura-config-page-status-side.right-side.status-side-hidden {
-  transform: translateX(-5rem);
-  opacity: 0;
-}
-
-.aura-config-page-status-el .version-type {
-  font-size: 20px;
-  font-weight: 500;
-}
-
-.aura-config-page-status-el .version-content {
-  font-size: 16px;
-  margin-top: 5px;
-  opacity: 0.625;
-}
+@import url("./css/status.css");
 
 /* Operation */
 
-.aura-config-page-operation-area {
-  display: flex;
-  flex-direction: column;
-  align-items: center;
-  justify-content: flex-end;
-  flex: 1;
-  width: 100%;
-  overflow-y: auto;
-}
+@import url("./css/operation.css");
 
-.aura-config-page-operation-area::-webkit-scrollbar {
-  display: none;
-}
+/* Config Status Notify */
 
-.aura-config-page-operation-area.subpage-expanded {
-  flex: 15;
-}
-
-.aura-config-page-subpage-container {
-  width: 100%;
-  height: 0;
-  background-color: rgba(255, 255, 255, 0.825);
-  z-index: 6000;
-  overflow-y: scroll;
-
-  opacity: 0;
-
-  transition: all 0.5s;
-}
-
-.aura-config-page-subpage-container::-webkit-scrollbar {
-  display: none;
-}
-
-.aura-config-page-operation-area.subpage-expanded
-  .aura-config-page-subpage-container {
-  height: calc(100% - 40px - 4rem);
-  opacity: 1;
-}
-
-.aura-config-page-operation-container {
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  width: 100%;
-  background-color: rgba(255, 255, 255, 0.1);
-  padding-left: 1rem;
-  padding-right: 1rem;
-}
-
-.aura-config-page-operation-container.hide-other-operations
-  .aura-config-page-operation-el:not(.preserve-operation) {
-  max-width: 0;
-  opacity: 0;
-}
-
-.aura-config-page-operation-container.hide-other-operations
-  .aura-config-page-operation-el.preserve-operation {
-  flex: 0.25;
-}
-
-.aura-config-page-operation-el {
-  display: flex;
-  flex-direction: row;
-  align-items: center;
-  justify-content: center;
-  flex: 1;
-  padding-top: 2rem;
-  padding-bottom: 2rem;
-  overflow: hidden;
-  white-space: nowrap;
-
-  max-width: 25%;
-  opacity: 1;
-  transform: translateY(0);
-
-  transition: opacity 0.5s, transform 0.5s,
-    max-width cubic-bezier(0, 0.42, 0.18, 1) 0.5s;
-}
-
-.aura-config-page-operation-el.operation-el-show:hover {
-  cursor: pointer;
-}
-
-.aura-config-page-operation-el.operation-el-show[aura-disabled="true"]:hover {
-  cursor: not-allowed;
-}
-
-.aura-config-page-operation-el.operation-el-hidden {
-  transform: translateY(2rem);
-  opacity: 0;
-}
-
-.aura-config-page-operation-el.operation-el-show
-  .aura-config-page-operation-body {
-  opacity: 1;
-  transition: opacity 0.25s;
-}
-
-.aura-config-page-operation-el.operation-el-show[aura-disabled="true"]
-  .aura-config-page-operation-body {
-  transition: opacity 0.5s;
-}
-
-.aura-config-page-operation-el.operation-el-show:not(.preserve-operation):hover
-  .aura-config-page-operation-body {
-  opacity: 0.625;
-}
-
-.aura-config-page-operation-el.operation-el-show[aura-disabled="true"]:hover
-  .aura-config-page-operation-body {
-  opacity: 0.25;
-}
-
-.aura-config-page-operation-el.operation-el-show:not(.preserve-operation):active
-  .aura-config-page-operation-body {
-  opacity: 0.25;
-}
-
-.aura-config-page-operation-el.operation-el-show[aura-disabled="true"]::after {
-  content: "别急嘛, 还在开发呢...";
-  font-size: 16px;
-  opacity: 0;
-  color: white;
-  position: absolute;
-
-  transition: all 0.5s;
-}
-
-.aura-config-page-operation-el.operation-el-show[aura-disabled="true"]:hover::after,
-.aura-config-page-operation-el.operation-el-show[aura-disabled="true"]:active::after {
-  opacity: 1;
-}
-
-.aura-config-page-operation-body {
-  display: flex;
-  align-items: center;
-  justify-content: center;
-}
-
-.aura-config-page-operation-el img {
-  max-width: 40px;
-  margin-right: 20px;
-}
-
-.aura-config-page-operation-el .config-operation-title {
-  color: white;
-  font-size: large;
-}
-
-.aura-config-page-operation-el .config-operation-description {
-  color: white;
-  opacity: 0.75;
-  font-size: small;
-}
+@import url("./css/configStatusNotify.css");
 
 /* Auth Dialog */
 
-.aura-config-page-auth-dialog-area {
-  position: absolute;
-  height: calc(100% - 40px);
-  width: 100%;
-  top: 40px;
-  left: 0;
-  display: flex;
-  justify-content: center;
-  align-items: center;
-  z-index: 10000;
-  background-color: rgba(255, 255, 255, 0.35);
-
-  opacity: 1;
-  transition: all 0.5s;
-}
-
-.aura-config-page-auth-dialog-area.blur-enabled {
-  height: 100%;
-  top: 0;
-  background-color: rgba(255, 255, 255, 0.15);
-  backdrop-filter: blur(5px);
-  filter: blur(0.1px);
-  /* ↑ 似乎会导致性能问题 */
-}
-
-.acp-ada-hidden {
-  opacity: 0;
-}
-
-.acp-ada-hidden.blur-enabled {
-  backdrop-filter: blur(0.1px);
-  filter: unset;
-}
-
-.aura-config-page-auth-dialog {
-  height: 40%;
-  width: 100%;
-  background-color: rgba(255, 255, 255, 0.625);
-  display: flex;
-  flex-direction: column;
-  text-align: center;
-  align-items: center;
-  padding-top: 2rem;
-  padding-bottom: 2rem;
-}
-
-.acp-auth-dialog-title {
-  font-size: x-large;
-  margin-bottom: 1.5rem;
-}
-
-#acp-auth-user-input {
-  max-width: 50%;
-  /* background-color: rgba(255, 255, 255, 0.5); */
-  border-radius: 35px;
-  margin-bottom: 2rem;
-}
-
-#acp-auth-user-input.invalid {
-  animation: invalidShake 0.6s linear;
-}
-
-.acp-auth-confirm-btn {
-  background-color: transparent;
-  border-radius: 35px;
-  border: 1px solid rgba(0, 0, 0, 0.3);
-  padding: 0.5rem;
-}
-
-.acp-auth-confirm-btn .layui-icon {
-  font-size: 24px;
-  margin-left: 2px;
-}
+@import url("./css/authDialog.css");
 
 /* Toast */
 
-.aura-config-page-toast-area {
-  z-index: 9000;
-}
-
-.aura-config-page-toast-area .toast {
-  --bs-toast-border-width: 0 !important;
-  --bs-toast-bg: #fff !important;
-}
-
-.aura-config-page-toast-area .toast-header {
-  background-color: rgb(255, 234, 202);
-
-  border-top-left-radius: var(--bs-toast-border-radius);
-  border-top-right-radius: var(--bs-toast-border-radius);
-}
-
-.aura-config-page-toast-area .toast.acp-toast-emerg .toast-header {
-  background-color: rgb(255, 202, 202);
-}
-
-.aura-config-page-toast-area .toast-header * {
-  color: rgba(234, 126, 14, 0.85);
-}
-
-.aura-config-page-toast-area .toast.acp-toast-emerg .toast-header * {
-  color: rgba(234, 65, 14, 0.85);
-}
-
-.aura-config-page-toast-area .toast-body p {
-  margin-bottom: var(--bs-toast-padding-x);
-}
-
-.aura-config-page-toast-area .toast-header .layui-icon {
-  font-weight: bolder;
-  margin-right: 0.5rem;
-  font-size: 18px;
-}
+@import url("./css/toast.css");

src/aura/ui/pages/config/config.html

@@ -1,4 +1,8 @@
-<div class="aura-config-page-root-inactive aura-config-page-root">
+<div
+  class="aura-config-page-root-inactive aura-config-page-root"
+  style="display: none"
+>
+  <!-- display: none 用于防止 CSS 还未加载完成时, 用户看到错乱的样式 -->
   <div class="header-collapsed aura-config-page-header-area">
     <div class="aura-config-page-app-bar" style="-webkit-app-region: drag">
       <div
@@ -66,6 +70,28 @@
   <div class="aura-config-page-operation-area">
     <div class="aura-config-page-subpage-container"></div>
     <div class="aura-config-page-operation-container">
+      <div class="acp-config-status-notify hidden fully-hidden">
+        <div class="acp-config-status-notify-area">
+          <div class="acp-config-status-notify-main-content">
+            <i class="layui-icon layui-icon-component acsn-main-icon"></i>
+            <p class="acsn-main-title">修改的配置暂未保存</p>
+            <button
+              type="button"
+              class="btn btn-outline-primary btn-sm acsn-save-btn"
+              onclick="window.__HUGO_AURA_UI_FUNCTIONS__.config.handleSaveConfig()"
+            >
+              保存配置
+            </button>
+          </div>
+
+          <div
+            class="acp-config-status-notify-success acsn-success-hidden acsn-success-fully-hidden"
+          >
+            <i class="layui-icon layui-icon-release"></i>
+            <p>保存成功</p>
+          </div>
+        </div>
+      </div>
       <div
         class="operation-el-hidden aura-config-page-operation-el"
         onclick="window.__HUGO_AURA_UI_FUNCTIONS__.config.toggleSubConfig('disableLimitations', true)"
@@ -80,10 +106,9 @@
       </div>
       <div
         class="operation-el-hidden aura-config-page-operation-el"
-        aura-disabled="true"
+        onclick="window.__HUGO_AURA_UI_FUNCTIONS__.config.toggleSubConfig('behaviourCtrl', true)"
       >
         <!-- Still WIP -->
-        <!-- onclick="window.__HUGO_AURA_UI_FUNCTIONS__.config.toggleSubConfig('behaviourCtrl', true)" -->
         <div class="aura-config-page-operation-body">
           <img src="../../aura/ui/static/config/behaviour_mon.svg" />
           <div>
@@ -122,6 +147,7 @@
   <div
     class="aura-config-page-auth-dialog-area acp-ada-hidden"
     style="display: none"
+    aura-cancel="true"
   >
     <div class="aura-config-page-auth-dialog">
       <p class="acp-auth-dialog-title">验证您的身份</p>
@@ -134,12 +160,21 @@
         id="acp-auth-user-input"
       />
 
-      <button
-        class="acp-auth-confirm-btn"
-        onclick="global.__HUGO_AURA_UI_FUNCTIONS__.config.verifyAuthPassword()"
-      >
-        <i class="layui-icon layui-icon-right"></i>
-      </button>
+      <div class="acp-auth-btns-container">
+        <button
+          class="acp-auth-cancel-btn"
+          onclick="global.__HUGO_AURA_UI_FUNCTIONS__.config.handleNavBack()"
+        >
+          <i class="layui-icon layui-icon-return"></i>
+        </button>
+
+        <button
+          class="acp-auth-confirm-btn"
+          onclick="global.__HUGO_AURA_UI_FUNCTIONS__.config.verifyAuthPassword()"
+        >
+          <i class="layui-icon layui-icon-ok"></i>
+        </button>
+      </div>
     </div>
   </div>
 
@@ -154,13 +189,22 @@
         <div class="toast-header">
           <i class="layui-icon layui-icon-tips"></i>
           <strong class="me-auto">重载页面以应用设置</strong>
+          <button
+            type="button"
+            class="btn-close"
+            data-bs-dismiss="toast"
+          ></button>
         </div>
         <div class="toast-body">
           <p>请重载当前窗口以应用修改的设置</p>
+          <p>已修改的配置将自动保存</p>
           <button
             type="button"
             class="btn btn-primary btn-sm"
-            onclick="window.location.reload()"
+            onclick="(() => {
+              global.__HUGO_AURA_CONFIG_MGR__.writeConfig(global.__HUGO_AURA_CONFIG__);
+              window.location.reload();
+            })()"
           >
             重载页面
           </button>
@@ -178,13 +222,22 @@
         <div class="toast-header">
           <i class="layui-icon layui-icon-tips"></i>
           <strong class="me-auto">重启进程以应用设置</strong>
+          <button
+            type="button"
+            class="btn-close"
+            data-bs-dismiss="toast"
+          ></button>
         </div>
         <div class="toast-body">
           <p>请重启 Electron 进程以应用修改的设置</p>
+          <p>已修改的配置将自动保存</p>
           <button
             type="button"
             class="btn btn-primary btn-sm"
-            onclick="ipcRenderer.invoke('$aura.base.restartApplication')"
+            onclick="(() => {
+              global.__HUGO_AURA_CONFIG_MGR__.writeConfig(global.__HUGO_AURA_CONFIG__);
+              ipcRenderer.invoke('$aura.base.restartApplication')
+            })()"
           >
             重启进程
           </button>
@@ -202,9 +255,15 @@
         <div class="toast-header">
           <i class="layui-icon layui-icon-tips"></i>
           <strong class="me-auto">重启 PLS 进程以应用设置</strong>
+          <button
+            type="button"
+            class="btn-close"
+            data-bs-dismiss="toast"
+          ></button>
         </div>
         <div class="toast-body">
           <p>请重启 PLS 进程以应用修改的设置</p>
+          <p>已修改的配置将自动保存</p>
           <button
             type="button"
             class="btn btn-primary btn-sm"

src/aura/ui/pages/config/config.js

@@ -2,15 +2,29 @@ global.__HUGO_AURA_UI_REACTIVES__.config = {
   isInSubPage: false,
   currentActiveSubPage: "",
   authenticated: false,
+  isConfigPendingWrite: false,
 };
 
 global.__HUGO_AURA_UI_FUNCTIONS__.config = {
   handleNavBack: () => {
     if (global.__HUGO_AURA_UI_REACTIVES__.config.isInSubPage) {
+      const acsDialogAreaEl = document.getElementsByClassName(
+        "aura-config-page-auth-dialog-area"
+      )[0];
+      if (!Array.from(acsDialogAreaEl.classList).includes("acp-ada-hidden")) {
+        global.__HUGO_AURA_UI_FUNCTIONS__.config.hideAndResetAuthDialog();
+        return;
+      }
+
+      if (global.__HUGO_AURA_UI_REACTIVES__.config.isConfigPendingWrite) {
+        global.__HUGO_AURA_UI_FUNCTIONS__.config.handleSaveConfig();
+      }
       global.__HUGO_AURA_UI_FUNCTIONS__.config.toggleSubConfig(
         global.__HUGO_AURA_UI_REACTIVES__.config.currentActiveSubPage,
         false
       );
+      const onLeaveEvent = new CustomEvent("onCurConfigPageLeave");
+      document.dispatchEvent(onLeaveEvent);
     } else {
       global.__HUGO_AURA_UI_FUNCTIONS__.config.hideConfigPage();
     }
@@ -156,13 +170,8 @@ global.__HUGO_AURA_UI_FUNCTIONS__.config = {
       encPasswd ===
       global.__HUGO_AURA_CONFIG__.auraSettings.settingsPasswordWithSalt
     ) {
-      const acsDialogAreaEl = document.getElementsByClassName(
-        "aura-config-page-auth-dialog-area"
-      )[0];
-      acsDialogAreaEl.classList.add("acp-ada-hidden");
-      await window.__HUGO_AURA_GLOBAL__.utils.sleep(500);
-      acsDialogAreaEl.style = "display: none;";
-      await window.__HUGO_AURA_GLOBAL__.utils.sleep(250);
+      await global.__HUGO_AURA_UI_FUNCTIONS__.config.hideAndResetAuthDialog();
+      await global.__HUGO_AURA_GLOBAL__.utils.sleep(250);
       global.__HUGO_AURA_UI_REACTIVES__.config.authenticated = true;
       global.__HUGO_AURA_UI_FUNCTIONS__.config.showSecondPhaseAnim();
       return true;
@@ -171,6 +180,91 @@ global.__HUGO_AURA_UI_FUNCTIONS__.config = {
       return false;
     }
   },
+
+  hideAndResetAuthDialog: async () => {
+    const acsDialogAreaEl = document.getElementsByClassName(
+      "aura-config-page-auth-dialog-area"
+    )[0];
+    const acpAppBarEl = document.getElementsByClassName(
+      "aura-config-page-header-area"
+    )[0];
+    const acpDialogTitleEl = document.getElementsByClassName(
+      "acp-auth-dialog-title"
+    )[0];
+    const acpDialogConfirmBtnEl = document.getElementsByClassName(
+      "acp-auth-confirm-btn"
+    )[0];
+    const acpDialogCancelBtnEl = document.getElementsByClassName(
+      "acp-auth-cancel-btn"
+    )[0];
+    const inputEl = document.getElementById("acp-auth-user-input");
+    acsDialogAreaEl.classList.add("acp-ada-hidden");
+    acpAppBarEl.classList.remove("color-reverse");
+    await window.__HUGO_AURA_GLOBAL__.utils.sleep(500);
+    acsDialogAreaEl.style = "display: none;";
+    acpDialogTitleEl.textContent = "验证您的身份";
+    inputEl.value = "";
+    inputEl.classList.remove("invalid");
+    inputEl.classList.remove("is-invalid");
+    acpDialogConfirmBtnEl.onclick = (_evt) => {
+      global.__HUGO_AURA_UI_FUNCTIONS__.config.verifyAuthPassword();
+    };
+    acpDialogCancelBtnEl.onclick = (_evt) => {
+      global.__HUGO_AURA_UI_FUNCTIONS__.config.handleNavBack();
+    };
+  },
+
+  handleACSNShow: async () => {
+    const acsnRootEl = document.getElementsByClassName(
+      "acp-config-status-notify"
+    )[0];
+    acsnRootEl.classList.remove("fully-hidden");
+    await global.__HUGO_AURA_GLOBAL__.utils.sleep(10);
+    acsnRootEl.classList.remove("hidden");
+    return true;
+  },
+
+  handleSaveConfig: async () => {
+    const result = global.__HUGO_AURA_CONFIG_MGR__.writeConfig(
+      global.__HUGO_AURA_CONFIG__
+    );
+
+    if (result) {
+      global.__HUGO_AURA_UI_REACTIVES__.config.isConfigPendingWrite = false;
+      const acsnRootEl = document.getElementsByClassName(
+        "acp-config-status-notify"
+      )[0];
+      const acsnMainContentEl = document.getElementsByClassName(
+        "acp-config-status-notify-main-content"
+      )[0];
+      const acsnSuccessEl = document.getElementsByClassName(
+        "acp-config-status-notify-success"
+      )[0];
+      const acsnAreaEl = document.getElementsByClassName(
+        "acp-config-status-notify-area"
+      )[0];
+      acsnMainContentEl.classList.add("acsn-main-content-hidden");
+      acsnAreaEl.classList.add("transparent");
+      await global.__HUGO_AURA_GLOBAL__.utils.sleep(250);
+      acsnMainContentEl.classList.add("acsn-main-content-fully-hidden");
+      acsnSuccessEl.classList.remove("acsn-success-fully-hidden");
+      await global.__HUGO_AURA_GLOBAL__.utils.sleep(50);
+      acsnSuccessEl.classList.remove("acsn-success-hidden");
+      await global.__HUGO_AURA_GLOBAL__.utils.sleep(1500);
+      acsnRootEl.classList.add("hidden");
+      await global.__HUGO_AURA_GLOBAL__.utils.sleep(500);
+      acsnRootEl.classList.add("fully-hidden");
+      await global.__HUGO_AURA_GLOBAL__.utils.sleep(10);
+      // Reset class
+      acsnMainContentEl.className = "acp-config-status-notify-main-content";
+      acsnAreaEl.className = "acp-config-status-notify-area";
+      acsnSuccessEl.className =
+        "acp-config-status-notify-success acsn-success-hidden acsn-success-fully-hidden";
+      return true;
+    } else {
+      // TODO: Error handling
+    }
+  },
 };
 
 (() => {
@@ -237,15 +331,13 @@ global.__HUGO_AURA_UI_FUNCTIONS__.config = {
       const acsDialogAreaEl = document.getElementsByClassName(
         "aura-config-page-auth-dialog-area"
       )[0];
+      const acpAppBarEl = document.getElementsByClassName(
+        "aura-config-page-header-area"
+      )[0];
       acsDialogAreaEl.style = "";
-      if (
-        global.__HUGO_AURA_CONFIG__.auraSettings.appearance
-          .enablePasswdDialogBlur
-      ) {
-        acsDialogAreaEl.classList.add("blur-enabled");
-      }
       await window.__HUGO_AURA_GLOBAL__.utils.sleep(500);
       acsDialogAreaEl.classList.remove("acp-ada-hidden");
+      acpAppBarEl.classList.add("color-reverse");
     }
   };
 

src/aura/ui/pages/config/css/authDialog.css

@@ -0,0 +1,95 @@
+.aura-config-page-auth-dialog-area {
+  position: absolute;
+  height: 100%;
+  width: 100%;
+  top: 0;
+  left: 0;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  z-index: 10000;
+  background-color: rgba(255, 255, 255, 0.5);
+
+  opacity: 1;
+  transition: all 0.5s;
+}
+
+.acp-ada-hidden {
+  opacity: 0;
+}
+
+.aura-config-page-auth-dialog {
+  height: 40%;
+  width: 100%;
+  background-color: rgba(255, 255, 255, 0.75);
+  display: flex;
+  flex-direction: column;
+  text-align: center;
+  align-items: center;
+  padding-top: 2rem;
+  padding-bottom: 2rem;
+}
+
+.acp-auth-dialog-title {
+  font-size: x-large;
+  margin-bottom: 1.5rem;
+}
+
+#acp-auth-user-input {
+  max-width: 50%;
+  /* background-color: rgba(255, 255, 255, 0.5); */
+  border-radius: 35px;
+  margin-bottom: 2rem;
+}
+
+#acp-auth-user-input.invalid {
+  animation: invalidShake 0.6s linear;
+}
+
+.acp-auth-btns-container {
+  display: flex;
+  justify-content: center;
+  align-items: center;
+}
+
+.acp-auth-btns-container button {
+  transition: all 0.25s;
+}
+
+.acp-auth-btns-container button:hover {
+  opacity: 0.5;
+}
+
+.acp-auth-btns-container button:active {
+  opacity: 0.25;
+}
+
+.acp-auth-confirm-btn,
+.acp-auth-cancel-btn {
+  border-radius: 35px;
+  padding: 0.5rem;
+}
+
+.acp-auth-confirm-btn {
+  background: linear-gradient(135deg, #218fff 0%, #3fbaff 100%);
+  border: 0;
+}
+
+.acp-auth-confirm-btn .layui-icon {
+  font-size: 24px;
+  color: white;
+}
+
+.acp-auth-cancel-btn .layui-icon {
+  font-size: 24px;
+}
+
+.acp-auth-cancel-btn {
+  background-color: transparent;
+  margin-right: 3rem;
+  border: 1px solid rgba(0, 0, 0, 0.3);
+}
+
+.aura-config-page-auth-dialog-area[aura-cancel="false"] .acp-auth-cancel-btn {
+  display: none;
+}

src/aura/ui/pages/config/css/configStatusNotify.css

@@ -0,0 +1,114 @@
+.acp-config-status-notify {
+  position: absolute;
+  height: calc(40px + 4rem);
+  width: 100%;
+  background-color: rgba(255, 255, 255, 0.1);
+  backdrop-filter: blur(5px);
+  filter: blur(0.1px);
+  z-index: 15000;
+
+  display: flex;
+  justify-content: center;
+  align-items: center;
+
+  transition: all 0.5s;
+}
+
+.acp-config-status-notify.hidden {
+  backdrop-filter: blur(0.1px);
+  filter: unset;
+  opacity: 0;
+}
+
+.acp-config-status-notify.fully-hidden {
+  display: none;
+}
+
+.acp-config-status-notify-area {
+  height: 100%;
+  width: 100%;
+  background-color: rgba(255, 255, 255, 0.5);
+  color: rgba(0, 0, 0, 0.6);
+
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  align-items: center;
+
+  transition: background-color 0.25s;
+}
+
+.acp-config-status-notify-area.transparent {
+  background-color: transparent;
+}
+
+.acp-config-status-notify-main-content {
+  display: flex;
+  flex-direction: row;
+  justify-content: center;
+  align-items: center;
+  /* margin-bottom: 0.75rem; */
+
+  opacity: 1;
+  transition: opacity 0.25s;
+}
+
+.acp-config-status-notify-main-content.acsn-main-content-hidden {
+  opacity: 0;
+  pointer-events: none;
+}
+
+.acp-config-status-notify-main-content.acsn-main-content-fully-hidden {
+  display: none;
+}
+
+.acp-config-status-notify-area .acsn-main-icon {
+  font-size: 24px;
+}
+
+.acp-config-status-notify-area .acsn-main-title {
+  font-size: large;
+  margin-left: 0.5rem;
+  margin-right: 2.25rem;
+}
+
+.acp-config-status-notify-area .acsn-save-btn {
+  margin-top: 2px; /* 可能是中文导致的 */
+
+  opacity: 1;
+  transition: all 0.25s;
+}
+
+.acp-config-status-notify-area .acsn-save-btn:active {
+  opacity: 0.625;
+}
+
+.acp-config-status-notify-success {
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  align-items: center;
+  pointer-events: none;
+
+  color: white;
+
+  opacity: 1;
+  transition: opacity 0.25s;
+}
+
+.acp-config-status-notify-success.acsn-success-hidden {
+  opacity: 0;
+}
+
+.acp-config-status-notify-success.acsn-success-fully-hidden {
+  display: none;
+}
+
+.acp-config-status-notify-success .layui-icon {
+  font-size: 26px;
+}
+
+.acp-config-status-notify-success p {
+  font-size: large;
+  margin-top: 0.2rem;
+}

src/aura/ui/pages/config/css/general.css

@@ -0,0 +1,33 @@
+#aura-container-Aura-UI-Assistant-Config {
+  position: absolute;
+  top: 0;
+  left: 0;
+  height: 100%;
+  width: 100%;
+  z-index: 1000;
+}
+
+.aura-config-page-root {
+  position: absolute;
+  top: 0;
+  left: 0;
+  height: 100%;
+  width: 100%;
+  background: url("../../../../../app.asar/public/ae247697b4639c92bd008d0ea7d13b53.png");
+  /* 这里不用 background-size: cover; 的效果反而更舒服一些... */
+
+  display: flex !important;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+
+  opacity: 1;
+  transform: scale(1);
+
+  transition: all 0.5s;
+}
+
+.aura-config-page-root-inactive {
+  opacity: 0;
+  transform: scale(1.5);
+}

src/aura/ui/pages/config/css/header.css

@@ -0,0 +1,50 @@
+.aura-config-page-header-area {
+  flex: 1;
+  display: flex;
+  flex-direction: row;
+  justify-content: flex-start;
+  width: 100%;
+  padding-left: 8px;
+  padding-right: 8px;
+  color: white;
+  z-index: 12000;
+
+  opacity: 1;
+  transform: translateY(0);
+
+  transition: all 0.5s;
+}
+
+.aura-config-page-header-area.color-reverse {
+  color: rgba(0, 0, 0, 0.8);
+}
+
+.aura-config-page-header-area .iconfont {
+  font-size: 24px;
+}
+
+.aura-config-page-header-area .iconfont:hover {
+  opacity: 0.75;
+  cursor: pointer;
+}
+
+.aura-config-page-header-area .iconfont:active {
+  opacity: 0.375;
+}
+
+.aura-config-page-header-area p {
+  margin-top: -1px;
+}
+
+.aura-config-page-header-area.header-collapsed {
+  transform: translateY(-1rem);
+  opacity: 0;
+}
+
+.aura-config-page-app-bar {
+  height: 40px;
+  display: flex;
+  justify-content: flex-start;
+  align-items: center;
+  width: 100%;
+}

src/aura/ui/pages/config/css/operation.css

@@ -0,0 +1,155 @@
+.aura-config-page-operation-area {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: flex-end;
+  flex: 1;
+  width: 100%;
+  overflow-y: auto;
+}
+
+.aura-config-page-operation-area::-webkit-scrollbar {
+  display: none;
+}
+
+.aura-config-page-operation-area.subpage-expanded {
+  flex: 15;
+}
+
+.aura-config-page-subpage-container {
+  width: 100%;
+  height: 0;
+  background-color: rgba(255, 255, 255, 0.825);
+  z-index: 6000;
+  overflow-y: scroll;
+
+  opacity: 0;
+
+  transition: all 0.5s;
+}
+
+.aura-config-page-subpage-container::-webkit-scrollbar {
+  display: none;
+}
+
+.aura-config-page-operation-area.subpage-expanded
+  .aura-config-page-subpage-container {
+  height: calc(100% - 40px - 4rem);
+  opacity: 1;
+}
+
+.aura-config-page-operation-container {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 100%;
+  background-color: rgba(255, 255, 255, 0.1);
+  padding-left: 1rem;
+  padding-right: 1rem;
+}
+
+.aura-config-page-operation-container.hide-other-operations
+  .aura-config-page-operation-el:not(.preserve-operation) {
+  max-width: 0;
+  opacity: 0;
+}
+
+.aura-config-page-operation-container.hide-other-operations
+  .aura-config-page-operation-el.preserve-operation {
+  flex: 0.25;
+}
+
+.aura-config-page-operation-el {
+  display: flex;
+  flex-direction: row;
+  align-items: center;
+  justify-content: center;
+  flex: 1;
+  padding-top: 2rem;
+  padding-bottom: 2rem;
+  overflow: hidden;
+  white-space: nowrap;
+
+  max-width: 25%;
+  opacity: 1;
+  transform: translateY(0);
+
+  transition: opacity 0.5s, transform 0.5s,
+    max-width cubic-bezier(0, 0.42, 0.18, 1) 0.5s;
+}
+
+.aura-config-page-operation-el.operation-el-show:hover {
+  cursor: pointer;
+}
+
+.aura-config-page-operation-el.operation-el-show[aura-disabled="true"]:hover {
+  cursor: not-allowed;
+}
+
+.aura-config-page-operation-el.operation-el-hidden {
+  transform: translateY(2rem);
+  opacity: 0;
+}
+
+.aura-config-page-operation-el.operation-el-show
+  .aura-config-page-operation-body {
+  opacity: 1;
+  transition: opacity 0.25s;
+}
+
+.aura-config-page-operation-el.operation-el-show[aura-disabled="true"]
+  .aura-config-page-operation-body {
+  transition: opacity 0.5s;
+}
+
+.aura-config-page-operation-el.operation-el-show:not(.preserve-operation):hover
+  .aura-config-page-operation-body {
+  opacity: 0.625;
+}
+
+.aura-config-page-operation-el.operation-el-show[aura-disabled="true"]:hover
+  .aura-config-page-operation-body {
+  opacity: 0.25;
+}
+
+.aura-config-page-operation-el.operation-el-show:not(.preserve-operation):active
+  .aura-config-page-operation-body {
+  opacity: 0.25;
+}
+
+.aura-config-page-operation-el.operation-el-show[aura-disabled="true"]::after {
+  content: "别急嘛, 还在开发呢...";
+  font-size: 16px;
+  opacity: 0;
+  color: white;
+  position: absolute;
+
+  transition: all 0.5s;
+}
+
+.aura-config-page-operation-el.operation-el-show[aura-disabled="true"]:hover::after,
+.aura-config-page-operation-el.operation-el-show[aura-disabled="true"]:active::after {
+  opacity: 1;
+}
+
+.aura-config-page-operation-body {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.aura-config-page-operation-el img {
+  max-width: 40px;
+  margin-right: 20px;
+}
+
+.aura-config-page-operation-el .config-operation-title {
+  color: white;
+  font-size: large;
+}
+
+.aura-config-page-operation-el .config-operation-description {
+  color: white;
+  opacity: 0.75;
+  font-size: small;
+}

src/aura/ui/pages/config/css/status.css

@@ -0,0 +1,123 @@
+.aura-config-page-status-container {
+  flex: 1;
+  width: 100%;
+  align-self: center;
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  align-items: center;
+
+  opacity: 1;
+
+  transition: all 0.5s;
+}
+
+.aura-config-page-status-container-hidden {
+  position: absolute;
+  opacity: 0;
+}
+
+.aura-config-page-status-main,
+.aura-config-page-status-description {
+  width: 100%;
+  display: flex;
+  flex-direction: row;
+  justify-content: center;
+  align-items: center;
+}
+
+.aura-config-page-status-description {
+  margin-top: 0.5rem;
+  transform: translateY(0);
+  opacity: 1;
+
+  transition: all 0.5s;
+}
+
+.aura-config-page-status-description.status-description-hidden {
+  transform: translateY(-2rem);
+  opacity: 0;
+}
+
+.aura-config-page-status-description p {
+  font-size: 18px;
+  margin-left: 15px;
+  margin-top: -2px;
+  color: white;
+  font-family: "Consolas", "Microsoft YaHei", sans-serif;
+}
+
+.aura-config-page-status-description i {
+  color: white;
+}
+
+.aura-config-page-central-aura-logo {
+  margin: 0.5rem 3rem;
+  width: 17.5%;
+}
+
+.aura-config-hr-vertical {
+  height: 3.75rem;
+  width: 1px;
+  background-color: rgba(255, 255, 255, 0.3);
+  margin-left: 30px;
+  margin-right: 30px;
+  border: none;
+}
+
+.aura-config-page-status-el {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  font-family: "Consolas", monospace;
+  color: white;
+
+  /*
+  .version-type {
+    content: "I want to use scss plz 😇"
+  }
+  */
+}
+
+.aura-config-page-status-side {
+  height: 30%;
+  display: flex;
+  flex-direction: row;
+  align-items: center;
+  flex: 1;
+
+  transform: translateX(0);
+  opacity: 1;
+
+  transition: transform 0.5s, opacity 0.5s;
+}
+
+.aura-config-page-status-side.left-side {
+  justify-content: flex-end;
+}
+
+.aura-config-page-status-side.left-side.status-side-hidden {
+  transform: translateX(5rem);
+  opacity: 0;
+}
+
+.aura-config-page-status-side.right-side {
+  justify-content: flex-start;
+}
+
+.aura-config-page-status-side.right-side.status-side-hidden {
+  transform: translateX(-5rem);
+  opacity: 0;
+}
+
+.aura-config-page-status-el .version-type {
+  font-size: 20px;
+  font-weight: 500;
+}
+
+.aura-config-page-status-el .version-content {
+  font-size: 16px;
+  margin-top: 5px;
+  opacity: 0.625;
+}

src/aura/ui/pages/config/css/toast.css

@@ -0,0 +1,37 @@
+.aura-config-page-toast-area {
+  z-index: 20000;
+}
+
+.aura-config-page-toast-area .toast {
+  --bs-toast-border-width: 0 !important;
+  --bs-toast-bg: #fff !important;
+}
+
+.aura-config-page-toast-area .toast-header {
+  background-color: rgb(255, 234, 202);
+
+  border-top-left-radius: var(--bs-toast-border-radius);
+  border-top-right-radius: var(--bs-toast-border-radius);
+}
+
+.aura-config-page-toast-area .toast.acp-toast-emerg .toast-header {
+  background-color: rgb(255, 202, 202);
+}
+
+.aura-config-page-toast-area .toast-header * {
+  color: rgba(234, 126, 14, 0.85);
+}
+
+.aura-config-page-toast-area .toast.acp-toast-emerg .toast-header * {
+  color: rgba(234, 65, 14, 0.85);
+}
+
+.aura-config-page-toast-area .toast-body p {
+  margin-bottom: var(--bs-toast-padding-x);
+}
+
+.aura-config-page-toast-area .toast-header .layui-icon {
+  font-weight: bolder;
+  margin-right: 0.5rem;
+  font-size: 18px;
+}

src/aura/ui/pages/configSubPages/behaviourCtrl/behaviourCtrl.js

@@ -7,6 +7,7 @@
   } = require(`${REQUIRE_BASE}/../../../../composables/settingsRenderer`);
 
   const { basicSettings } = require(`${REQUIRE_BASE}/basic`);
+  const { deviceSecuritySettings } = require(`${REQUIRE_BASE}/deviceSecurity`);
 
   const {
     updatePlsSettingsFromLocal,
@@ -24,19 +25,27 @@
     settingsRenderer(basicSubPageEl, basicSettings);
   };
 
+  const initDeviceSecuritySettingsPage = () => {
+    const deviceSecuritySubPageEl = document.getElementById(
+      "security-config-subpage"
+    );
+    settingsRenderer(deviceSecuritySubPageEl, deviceSecuritySettings);
+  };
+
   const renderSubPages = async () => {
     await updatePlsSettingsFromLocal();
     await updatePlsRulesFromLocal();
 
     initBasicSettingsPage();
+    initDeviceSecuritySettingsPage();
   };
 
   const onMounted = () => {
     const rootEl = document.getElementById("acs-behaviour-control-el");
     initStatusPage();
-    renderSubPages();
     setTimeout(() => {
       rootEl.classList.remove("acs-behaviour-control-hidden");
+      renderSubPages(); // 如果立即渲染子页面, 此时 plsRules 还未初始化, 会导致子页面 auraIf 失效
     }, 500);
   };
 

src/aura/ui/pages/configSubPages/behaviourCtrl/plsStatus.css

@@ -18,12 +18,121 @@
 }
 
 .acs-bc-pls-status-page-main-logo {
-  max-width: 13.5%;
+  max-width: 11%;
   opacity: 0.45;
   margin-top: 1.5rem;
   margin-bottom: 1.5rem;
 }
 
+.acs-bc-psp-operations-container {
+  display: flex;
+  flex-direction: row;
+  justify-content: center;
+  align-items: center;
+  gap: 0.5rem;
+  margin-bottom: 1rem;
+}
+
+.acs-bc-psp-operations-container.acs-bc-psp-oper-ctnr-hidden {
+  display: none;
+}
+
+.acs-bc-psp-operation-btn {
+  --svg-color: rgb(17, 140, 255);
+
+  display: flex;
+  flex-direction: row;
+  justify-content: center;
+  align-items: center;
+  margin-left: 0.75rem;
+  margin-right: 0.75rem;
+
+  transition: opacity 0.25s, color 0.5s;
+}
+
+.acs-bc-psp-operation-btn p {
+  font-size: normal;
+  margin-left: 5px;
+  margin-top: -1px;
+  color: var(--svg-color);
+}
+
+.acs-bc-psp-operation-btn svg {
+  max-width: 16px;
+  max-height: 16px;
+}
+
+.acs-bc-psp-operation-btn.acs-bc-psp-o-btn-dangerous {
+  --svg-color: rgb(244, 8, 8);
+}
+
+.acs-bc-psp-operation-btn[aura-disabled="true"] {
+  --svg-color: rgba(0, 0, 0, 0.25);
+}
+
+.acs-bc-psp-operation-btn[aura-disabled="true"]:hover,
+.acs-bc-psp-operation-btn[aura-disabled="true"]:active {
+  cursor: not-allowed !important;
+  opacity: 1 !important;
+}
+
+.acs-bc-psp-operation-btn:hover,
+.acs-bc-psp-operation-btn:active {
+  cursor: pointer;
+}
+
+.acs-bc-psp-operation-btn:hover {
+  opacity: 0.6;
+}
+
+.acs-bc-psp-operation-btn:active {
+  opacity: 0.3;
+}
+
+.acs-bc-psp-download-progress-area {
+  display: flex;
+  flex-direction: column;
+  width: 80%;
+  justify-content: center;
+  align-items: center;
+}
+
+.acs-bc-psp-download-progress-area.acs-bc-psp-dl-pbar-hidden {
+  display: none;
+}
+
+.acs-bc-psp-download-progress-area .progress {
+  height: 2px;
+  width: 80%;
+  margin-bottom: 0.6rem;
+}
+
+.acs-bc-psp-download-progress-area .progress-bar {
+  transition: all 0.15s;
+}
+
+.acs-bc-psp-download-progress-area #acsBcPspDownloadPbarDesc {
+  opacity: 0.6;
+  margin-bottom: 0.25rem;
+}
+
+.acs-bc-psp-download-progress-info-area {
+  display: flex;
+}
+
+.acs-bc-psp-download-progress-info-area .acs-bc-psp-operation-btn {
+  margin-left: 1rem;
+  margin-bottom: 0.25rem;
+}
+
+.acs-bc-psp-download-progress-info-area .acs-bc-psp-operation-btn.hidden {
+  display: none;
+}
+
+.acs-bc-psp-download-progress-info-area .acs-bc-psp-operation-btn svg {
+  margin-top: 1px;
+}
+
 .acs-bc-pls-status-page-status-el {
   display: flex;
   align-items: center;
@@ -76,3 +185,62 @@
 .acs-bc-pls-status-page-status-area.failed p {
   color: rgb(175, 0, 0);
 }
+
+.acs-bc-pls-status-page-status-area.warning
+  .acs-bc-pls-status-page-status-area-circle {
+  background-color: rgb(212, 127, 0);
+}
+
+.acs-bc-pls-status-page-status-area.warning p {
+  color: rgb(212, 127, 0);
+}
+
+.acs-bc-pls-status-page-status-area.info
+  .acs-bc-pls-status-page-status-area-circle {
+  background-color: #3d78ff;
+}
+
+.acs-bc-pls-status-page-status-area.info p {
+  color: #3d78ff;
+}
+
+.acs-bc-psp-toast.body-display-none .toast-body {
+  display: none;
+}
+
+.acs-bc-psp-toast.body-display-none .toast-header {
+  border-bottom: none;
+}
+
+.acs-bc-psp-toast[closable="false"] .btn-close {
+  display: none;
+}
+
+.acs-bc-psp-toast[variant="success"] .toast-header {
+  background-color: rgb(6, 196, 65);
+  color: rgb(255, 255, 255);
+}
+
+.acs-bc-psp-toast[variant="warning"] .toast-header {
+  background-color: rgb(225, 178, 44);
+  color: rgb(255 255 255);
+}
+
+.acs-bc-psp-toast[variant="error"] .toast-header {
+  background-color: rgb(217, 57, 4);
+  color: rgb(255 255 255);
+}
+
+.acs-bc-psp-toast[variant="info"] .toast-header {
+  background-color: rgb(0, 149, 222);
+  color: rgb(255 255 255);
+}
+
+.acs-bc-psp-toast[variant="success"] .btn-close,
+.acs-bc-psp-toast[variant="warning"] .btn-close,
+.acs-bc-psp-toast[variant="error"] .btn-close,
+.acs-bc-psp-toast[variant="info"] .btn-close {
+  color: rgb(255, 255, 255);
+  filter: invert(1);
+  opacity: 0.95;
+}

src/aura/ui/pages/configSubPages/behaviourCtrl/plsStatus.html

@@ -1,7 +1,7 @@
 <div class="acs-behaviour-control-pls-status-page">
   <p class="acs-bc-pls-status-page-pls-description">
-    HugoAura ProxyLayerServices (Aura-PLS) 是基于 Python + MITMProxy 实现的代理服务,
-    用于解密并修改希沃基础服务 (SeewoCore) 的 MQTT 数据包,
+    HugoAura ProxyLayerServices (Aura-PLS) 是基于 Python + MITMProxy
+    实现的代理服务, 用于解密并修改希沃基础服务 (SeewoCore) 的 MQTT 数据包,
     实现行为监控、伪造上报等功能
   </p>
   <img
@@ -9,6 +9,152 @@
     class="acs-bc-pls-status-page-main-logo"
   />
 
+  <div class="acs-bc-psp-operations-container">
+    <div class="acs-bc-psp-operation-btn" id="acsBcPsp-operBtn-Refresh">
+      <svg
+        xmlns="http://www.w3.org/2000/svg"
+        width="32"
+        height="32"
+        viewBox="0 0 32 32"
+      >
+        <path
+          fill="var(--svg-color)"
+          d="M26 18A10 10 0 1 1 16 8h6.182l-3.584 3.585L20 13l6-6l-6-6l-1.402 1.414L22.185 6H16a12 12 0 1 0 12 12Z"
+        />
+      </svg>
+      <p>刷新状态</p>
+    </div>
+
+    <div
+      class="acs-bc-psp-operation-btn"
+      aura-disabled="true"
+      id="acsBcPsp-operBtn-Download"
+    >
+      <svg
+        xmlns="http://www.w3.org/2000/svg"
+        width="32"
+        height="32"
+        viewBox="0 0 32 32"
+      >
+        <path
+          fill="var(--svg-color)"
+          d="M23.5 22H23v-2h.5a4.5 4.5 0 0 0 .36-9H23l-.1-.82a7 7 0 0 0-13.88 0L9 11h-.86a4.5 4.5 0 0 0 .36 9H9v2h-.5A6.5 6.5 0 0 1 7.2 9.14a9 9 0 0 1 17.6 0A6.5 6.5 0 0 1 23.5 22"
+        />
+        <path
+          fill="var(--svg-color)"
+          d="M17 26.17V14h-2v12.17l-2.59-2.58L11 25l5 5l5-5l-1.41-1.41z"
+        />
+      </svg>
+      <p>下载内核</p>
+    </div>
+
+    <div class="acs-bc-psp-operation-btn" id="acsBcPsp-operBtn-Install">
+      <svg
+        xmlns="http://www.w3.org/2000/svg"
+        width="32"
+        height="32"
+        viewBox="0 0 32 32"
+      >
+        <path
+          fill="var(--svg-color)"
+          d="m10 6l1.414-1.414L15 8.172V0h2v8.172l3.586-3.586L22 6l-6 6z"
+        />
+        <path
+          fill="var(--svg-color)"
+          d="M22 16a5.98 5.98 0 0 0-1.757-4.243L16 16l-4.243-4.243A6 6 0 1 0 22 16"
+        />
+        <path
+          fill="var(--svg-color)"
+          d="M30 16a13.96 13.96 0 0 0-4.105-9.895l-1.414 1.414a12 12 0 1 1-16.962 0L6.105 6.105A13.997 13.997 0 1 0 30 16"
+        />
+      </svg>
+      <p>安装服务</p>
+    </div>
+
+    <div
+      class="acs-bc-psp-operation-btn acs-bc-psp-o-btn-dangerous"
+      id="acsBcPsp-operBtn-Uninstall"
+    >
+      <svg
+        xmlns="http://www.w3.org/2000/svg"
+        width="32"
+        height="32"
+        viewBox="0 0 32 32"
+      >
+        <path
+          fill="var(--svg-color)"
+          d="M30 21.4L28.6 20L25 23.6L21.4 20L20 21.4l3.6 3.6l-3.6 3.6l1.4 1.4l3.6-3.6l3.6 3.6l1.4-1.4l-3.6-3.6z"
+        />
+        <path
+          fill="var(--svg-color)"
+          d="M15.4 30L5 23.8c-.6-.4-1-1-1-1.7V9.9c0-.7.4-1.4 1-1.7l10-5.9c.3-.2.6-.3 1-.3s.7.1 1 .3l10 5.9c.6.4 1 1 1 1.7V16h-2V9.9L16 4L6 9.9v12.2l10.5 6.2z"
+        />
+      </svg>
+      <p>卸载服务</p>
+    </div>
+
+    <div class="acs-bc-psp-operation-btn" id="acsBcPsp-operBtn-Start">
+      <svg
+        xmlns="http://www.w3.org/2000/svg"
+        width="32"
+        height="32"
+        viewBox="0 0 32 32"
+      >
+        <path
+          fill="var(--svg-color)"
+          d="M7 28a1 1 0 0 1-1-1V5a1 1 0 0 1 1.482-.876l20 11a1 1 0 0 1 0 1.752l-20 11A1 1 0 0 1 7 28M8 6.69v18.62L24.925 16Z"
+        />
+      </svg>
+      <p>启动服务</p>
+    </div>
+
+    <div class="acs-bc-psp-operation-btn" id="acsBcPsp-operBtn-Stop">
+      <svg
+        xmlns="http://www.w3.org/2000/svg"
+        width="32"
+        height="32"
+        viewBox="0 0 32 32"
+      >
+        <path
+          fill="var(--svg-color)"
+          d="M24 8v16H8V8zm0-2H8a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2"
+        />
+      </svg>
+      <p>停止服务</p>
+    </div>
+  </div>
+
+  <div class="acs-bc-psp-download-progress-area acs-bc-psp-dl-pbar-hidden">
+    <div class="progress" role="progressbar">
+      <div class="progress-bar" id="acsBcPspDownloadPbarEl"></div>
+    </div>
+    <div class="acs-bc-psp-download-progress-info-area">
+      <p id="acsBcPspDownloadPbarDesc">等待中...</p>
+      <div
+        class="acs-bc-psp-operation-btn hidden"
+        id="acsBcPspDownloadPbarCancelBtn"
+        onclick="global.__HUGO_AURA_UI_FUNCTIONS__.subConfig.plsStatus.cancelDownloadTask()"
+      >
+        <svg
+          xmlns="http://www.w3.org/2000/svg"
+          width="32"
+          height="32"
+          viewBox="0 0 32 32"
+        >
+          <path
+            fill="var(--svg-color)"
+            d="M9 10.555L10.555 9L23 21.444L21.444 23z"
+          />
+          <path
+            fill="var(--svg-color)"
+            d="M16 2A13.914 13.914 0 0 0 2 16a13.914 13.914 0 0 0 14 14a13.914 13.914 0 0 0 14-14A13.914 13.914 0 0 0 16 2m0 26a12 12 0 1 1 12-12a12.035 12.035 0 0 1-12 12"
+          />
+        </svg>
+        <p>取消操作</p>
+      </div>
+    </div>
+  </div>
+
   <div class="acs-bc-pls-status-page-status-el">
     <p>安装状态</p>
     <div
@@ -48,4 +194,22 @@
       <p id="acs-bc-psp-version-text">不可用</p>
     </div>
   </div>
+
+  <div class="toast-container position-fixed bottom-0 end-0 p-3">
+    <div
+      id="plsStatusNotifyToast"
+      class="acs-bc-psp-toast toast"
+      data-bs-autohide="false"
+    >
+      <div class="toast-header">
+        <strong class="me-auto" id="plsStatusNotifyToastTitle"></strong>
+        <button
+          type="button"
+          class="btn-close"
+          data-bs-dismiss="toast"
+        ></button>
+      </div>
+      <div class="toast-body" id="plsStatusNotifyToastBody"></div>
+    </div>
+  </div>
 </div>

src/aura/ui/pages/configSubPages/behaviourCtrl/plsStatus.js

@@ -1,11 +1,835 @@
+if (!global.__HUGO_AURA_UI_FUNCTIONS__.subConfig)
+  global.__HUGO_AURA_UI_FUNCTIONS__.subConfig = {};
+
+if (!global.__HUGO_AURA_UI_REACTIVES__.subConfig)
+  global.__HUGO_AURA_UI_REACTIVES__.subConfig = {};
+
 (() => {
   const REQUIRE_BASE = "../../aura/ui/pages/configSubPages/behaviourCtrl";
   const IPC_METHOD_BASE = "$aura.pls";
 
+  const lifecycleStatus = {
+    installed: false,
+    detached: false,
+    svcInstalled: false,
+    svcRunning: false,
+  };
+
+  global.__HUGO_AURA_UI_REACTIVES__.subConfig.plsStatus = {
+    toastAutoHideTimeout: null,
+    curDlTaskId: null,
+  };
+
+  global.__HUGO_AURA_UI_FUNCTIONS__.subConfig.plsStatus = {
+    updateToast: async (
+      variant,
+      title,
+      body = null,
+      closable = true,
+      autoHide = true,
+      hideAfter = 3000
+    ) => {
+      const toastRootEl = document.getElementById("plsStatusNotifyToast");
+      const toastHeaderEl = document.getElementById(
+        "plsStatusNotifyToastTitle"
+      );
+      const toastBodyEl = document.getElementById("plsStatusNotifyToastBody");
+
+      const bsToastIns = bootstrap.Toast.getOrCreateInstance(toastRootEl);
+      if (bsToastIns.isShown) {
+        bsToastIns.hide();
+        const timeout =
+          global.__HUGO_AURA_UI_REACTIVES__.subConfig.plsStatus
+            .toastAutoHideTimeout;
+        if (timeout) {
+          clearTimeout(timeout);
+        }
+        await global.__HUGO_AURA_GLOBAL__.utils.sleep(160);
+      }
+
+      toastRootEl.setAttribute("variant", variant);
+      toastHeaderEl.innerHTML = title;
+      if (body) {
+        toastBodyEl.innerHTML = body;
+        toastRootEl.classList.remove("body-display-none");
+      } else {
+        toastRootEl.classList.add("body-display-none");
+      }
+
+      toastRootEl.setAttribute("closable", closable.toString());
+
+      bsToastIns.show();
+      if (autoHide && hideAfter) {
+        global.__HUGO_AURA_UI_REACTIVES__.subConfig.plsStatus.toastAutoHideTimeout =
+          setTimeout(() => {
+            bsToastIns.hide();
+          }, hideAfter);
+      }
+    },
+
+    updateOperationBtnStatus: async (
+      btnName,
+      isDisabled,
+      btnContent = null
+    ) => {
+      const btnEl = document.getElementById(`acsBcPsp-operBtn-${btnName}`);
+      if (!btnEl) return false;
+      btnEl.setAttribute("aura-disabled", isDisabled ? "true" : "false");
+      if (btnContent) {
+        const btnPEl = btnEl.getElementsByTagName("p")[0];
+        btnPEl.textContent = btnContent;
+      }
+      if (isDisabled) {
+        btnEl.onclick = () => {};
+      } else {
+        switch (btnName) {
+          case "Refresh":
+            btnEl.onclick = () => {
+              global.__HUGO_AURA_UI_FUNCTIONS__.subConfig.plsStatus.updateToast(
+                "warning",
+                "正在更新",
+                null,
+                false,
+                false,
+                null
+              );
+              global.__HUGO_AURA_UI_FUNCTIONS__.subConfig.plsStatus.refreshPlsStatus();
+            };
+            break;
+          case "Download":
+            btnEl.onclick = async () => {
+              global.__HUGO_AURA_UI_FUNCTIONS__.subConfig.plsStatus.downloadPLSBin();
+            };
+            break;
+
+          // ↓ 这边的确可以把这些全都合并到一个可复用 fn 里去, 但没必要
+          // 如果后续要引入错误视觉反馈, 合并到单个 fn 反而会增加实现复杂度
+          case "Install":
+            btnEl.onclick = async () => {
+              global.__HUGO_AURA_UI_FUNCTIONS__.subConfig.plsStatus.updateOperationBtnStatus(
+                "Install",
+                true
+              );
+              global.__HUGO_AURA_UI_FUNCTIONS__.subConfig.plsStatus.updateToast(
+                "info",
+                "正在请求安装",
+                null,
+                false,
+                false,
+                null
+              );
+              const ret = await ipcRenderer.invoke(
+                `${IPC_METHOD_BASE}.plsLifecycleControl`,
+                { target: "instSvc" }
+              );
+              if (ret.success) {
+                lifecycleStatus.svcInstalled = true;
+                global.__HUGO_AURA_UI_FUNCTIONS__.subConfig.plsStatus.updateToast(
+                  "success",
+                  "服务安装成功",
+                  null,
+                  true,
+                  true,
+                  2000
+                );
+              } else {
+                global.__HUGO_AURA_UI_FUNCTIONS__.subConfig.plsStatus.updateToast(
+                  "error",
+                  "服务安装失败",
+                  `<p>${ret.errorObj}</p>`,
+                  true,
+                  false,
+                  null
+                );
+              }
+              global.__HUGO_AURA_UI_FUNCTIONS__.subConfig.plsStatus.updateStatusContent();
+            };
+            break;
+          case "Uninstall":
+            if (btnContent === "删除内核") {
+              btnEl.onclick = async () => {
+                global.__HUGO_AURA_UI_FUNCTIONS__.subConfig.plsStatus.updateOperationBtnStatus(
+                  "Uninstall",
+                  true
+                );
+                global.__HUGO_AURA_UI_FUNCTIONS__.subConfig.plsStatus.updateToast(
+                  "warning",
+                  "正在删除内核",
+                  null,
+                  false,
+                  false,
+                  null
+                );
+                const ret = await ipcRenderer.invoke(
+                  `${IPC_METHOD_BASE}.plsLifecycleControl`,
+                  { target: "rmBin" }
+                );
+                if (ret.success) {
+                  lifecycleStatus.installed = false;
+                  lifecycleStatus.svcInstalled = false;
+                  global.__HUGO_AURA__.plsStats.installed = false;
+                  global.__HUGO_AURA__.plsStats.connected = false;
+                  global.__HUGO_AURA__.plsStats.launched = false;
+                  ipcRenderer.invoke(
+                    `${IPC_METHOD_BASE}.updatePlsStats`,
+                    global.__HUGO_AURA__.plsStats
+                  );
+                  global.__HUGO_AURA_UI_FUNCTIONS__.subConfig.plsStatus.updateToast(
+                    "success",
+                    "内核已删除",
+                    null,
+                    true,
+                    true,
+                    2000
+                  );
+                } else {
+                  global.__HUGO_AURA_UI_FUNCTIONS__.subConfig.plsStatus.updateToast(
+                    "error",
+                    "内核删除失败",
+                    `<p>
+                      ${ret.errorObj ? ret.errorObj : "检查日志以获取详细信息"}
+                    </p>`,
+                    true,
+                    false,
+                    null
+                  );
+                }
+                global.__HUGO_AURA_UI_FUNCTIONS__.subConfig.plsStatus.updateStatusContent();
+              };
+            } else {
+              btnEl.onclick = async () => {
+                global.__HUGO_AURA_UI_FUNCTIONS__.subConfig.plsStatus.updateOperationBtnStatus(
+                  "Uninstall",
+                  true
+                );
+                global.__HUGO_AURA_UI_FUNCTIONS__.subConfig.plsStatus.updateToast(
+                  "info",
+                  lifecycleStatus.svcRunning
+                    ? "正在停止服务并卸载"
+                    : "正在请求卸载",
+                  null,
+                  false,
+                  false,
+                  null
+                );
+                if (lifecycleStatus.svcRunning) {
+                  const stopRet = await ipcRenderer.invoke(
+                    `${IPC_METHOD_BASE}.plsLifecycleControl`,
+                    { target: "stopSvc" }
+                  );
+                  if (!stopRet.success) {
+                    global.__HUGO_AURA_UI_FUNCTIONS__.subConfig.plsStatus.updateToast(
+                      "error",
+                      "服务卸载失败: 无法停止服务",
+                      `<p>${
+                        stopRet.errorObj
+                          ? stopRet.errorObj
+                          : "检查日志以获取详细信息"
+                      }</p>
+                      <p>
+                        您可以尝试手动停止 PLS 服务
+                      </p>`,
+                      true,
+                      false,
+                      null
+                    );
+                  } else {
+                    lifecycleStatus.svcRunning = false;
+                  }
+                }
+                const ret = await ipcRenderer.invoke(
+                  `${IPC_METHOD_BASE}.plsLifecycleControl`,
+                  { target: "rmSvc" }
+                );
+                if (ret.success) {
+                  lifecycleStatus.svcInstalled = false;
+                  global.__HUGO_AURA_UI_FUNCTIONS__.subConfig.plsStatus.updateToast(
+                    "success",
+                    "服务卸载成功",
+                    null,
+                    true,
+                    true,
+                    2000
+                  );
+                } else {
+                  global.__HUGO_AURA_UI_FUNCTIONS__.subConfig.plsStatus.updateToast(
+                    "error",
+                    "服务卸载失败",
+                    "<p>检查日志以获取详细信息</p>",
+                    true,
+                    false,
+                    null
+                  );
+                }
+                global.__HUGO_AURA_UI_FUNCTIONS__.subConfig.plsStatus.updateStatusContent();
+              };
+            }
+
+            break;
+          case "Start":
+            btnEl.onclick = async () => {
+              global.__HUGO_AURA_UI_FUNCTIONS__.subConfig.plsStatus.updateOperationBtnStatus(
+                "Start",
+                true
+              );
+              global.__HUGO_AURA_UI_FUNCTIONS__.subConfig.plsStatus.updateToast(
+                "info",
+                "正在请求启动",
+                null,
+                false,
+                false,
+                null
+              );
+              const ret = await ipcRenderer.invoke(
+                `${IPC_METHOD_BASE}.plsLifecycleControl`,
+                { target: "startSvc" }
+              );
+              if (ret.success) {
+                lifecycleStatus.svcRunning = true;
+                global.__HUGO_AURA_UI_FUNCTIONS__.subConfig.plsStatus.updateStatusContent();
+                global.__HUGO_AURA_UI_FUNCTIONS__.subConfig.plsStatus.updateToast(
+                  "success",
+                  "PLS 已启动",
+                  null,
+                  true,
+                  true,
+                  2000
+                );
+                await global.__HUGO_AURA_GLOBAL__.utils.sleep(100);
+                await ipcRenderer.invoke(`${IPC_METHOD_BASE}.retryPlsConnect`);
+                global.__HUGO_AURA_UI_FUNCTIONS__.subConfig.plsStatus.updateStatusContent();
+              } else {
+                global.__HUGO_AURA_UI_FUNCTIONS__.subConfig.plsStatus.updateStatusContent();
+                global.__HUGO_AURA_UI_FUNCTIONS__.subConfig.plsStatus.updateToast(
+                  "error",
+                  "PLS 启动失败",
+                  "<p>检查 PLS 日志目录以获取详细信息</p>",
+                  true,
+                  false,
+                  null
+                );
+              }
+            };
+            break;
+          case "Stop":
+            btnEl.onclick = async () => {
+              global.__HUGO_AURA_UI_FUNCTIONS__.subConfig.plsStatus.updateOperationBtnStatus(
+                "Stop",
+                true
+              );
+              global.__HUGO_AURA_UI_FUNCTIONS__.subConfig.plsStatus.updateToast(
+                "info",
+                "正在请求停止",
+                null,
+                false,
+                false,
+                null
+              );
+              const ret = await ipcRenderer.invoke(
+                `${IPC_METHOD_BASE}.plsLifecycleControl`,
+                { target: "stopSvc" }
+              );
+              if (ret.success) {
+                lifecycleStatus.svcRunning = false;
+                global.__HUGO_AURA_UI_FUNCTIONS__.subConfig.plsStatus.updateToast(
+                  "success",
+                  "PLS 已停止",
+                  null,
+                  true,
+                  true,
+                  2000
+                );
+              } else {
+                global.__HUGO_AURA_UI_FUNCTIONS__.subConfig.plsStatus.updateToast(
+                  "error",
+                  "PLS 停止失败",
+                  null,
+                  true,
+                  false,
+                  null
+                );
+                global.__HUGO_AURA_UI_FUNCTIONS__.subConfig.plsStatus.updateStatusContent();
+              }
+            };
+            break;
+          default:
+            break;
+        }
+      }
+      return true;
+    },
+
+    updateStatusContent: async () => {
+      const curPlsStats = await updatePlsStatusFromLocal();
+
+      if (curPlsStats.status === "downloading") {
+        GLOBAL_FUNCTIONS.downloadPLSBin(true);
+      }
+
+      const acIdInst = "acs-bc-psp-installStatus-container";
+      const atIdInst = "acs-bc-psp-installStatus-text";
+      switch (lifecycleStatus.installed) {
+        case true:
+          if (!lifecycleStatus.svcInstalled) {
+            updateStatusEl(acIdInst, atIdInst, "WARNING", "已下载, 服务未安装");
+            GLOBAL_FUNCTIONS.updateOperationBtnStatus("Install", false);
+            GLOBAL_FUNCTIONS.updateOperationBtnStatus(
+              "Uninstall",
+              false,
+              "删除内核"
+            );
+            GLOBAL_FUNCTIONS.updateOperationBtnStatus("Start", true);
+            GLOBAL_FUNCTIONS.updateOperationBtnStatus("Stop", true);
+          } else {
+            updateStatusEl(acIdInst, atIdInst, "SUCCESS", "已安装");
+            GLOBAL_FUNCTIONS.updateOperationBtnStatus("Install", true);
+            GLOBAL_FUNCTIONS.updateOperationBtnStatus(
+              "Uninstall",
+              false,
+              "卸载服务"
+            );
+          }
+          break;
+        case false:
+          updateStatusEl(acIdInst, atIdInst, "PENDING", "未下载");
+          GLOBAL_FUNCTIONS.updateOperationBtnStatus("Download", false);
+          GLOBAL_FUNCTIONS.updateOperationBtnStatus("Install", true);
+          GLOBAL_FUNCTIONS.updateOperationBtnStatus("Uninstall", true);
+          GLOBAL_FUNCTIONS.updateOperationBtnStatus("Start", true);
+          GLOBAL_FUNCTIONS.updateOperationBtnStatus("Stop", true);
+      }
+
+      const acIdLaunch = "acs-bc-psp-launchStatus-container";
+      const atIdLaunch = "acs-bc-psp-launchStatus-text";
+
+      if (lifecycleStatus.detached) {
+        updateStatusEl(acIdLaunch, atIdLaunch, "INFO", "已分离");
+        GLOBAL_FUNCTIONS.updateOperationBtnStatus("Start", true);
+        GLOBAL_FUNCTIONS.updateOperationBtnStatus("Stop", true);
+      } else if (lifecycleStatus.svcInstalled && lifecycleStatus.installed) {
+        switch (lifecycleStatus.svcRunning || curPlsStats.launched) {
+          case true:
+            if (curPlsStats.status !== "notReady") {
+              updateStatusEl(acIdLaunch, atIdLaunch, "SUCCESS", "已启动");
+              GLOBAL_FUNCTIONS.updateOperationBtnStatus("Start", true);
+              GLOBAL_FUNCTIONS.updateOperationBtnStatus("Stop", false);
+            } else {
+              updateStatusEl(acIdLaunch, atIdLaunch, "WARNING", "启动中");
+              GLOBAL_FUNCTIONS.updateOperationBtnStatus("Start", true);
+              GLOBAL_FUNCTIONS.updateOperationBtnStatus("Stop", false);
+            }
+            break;
+          case false:
+            updateStatusEl(acIdLaunch, atIdLaunch, "PENDING", "未启动");
+            GLOBAL_FUNCTIONS.updateOperationBtnStatus("Start", false);
+            GLOBAL_FUNCTIONS.updateOperationBtnStatus("Stop", true);
+            break;
+        }
+      }
+
+      const acIdConn = "acs-bc-psp-connStatus-container";
+      const atIdConn = "acs-bc-psp-connStatus-text";
+      switch (curPlsStats.connected) {
+        case true:
+          updateStatusEl(acIdConn, atIdConn, "SUCCESS", "已连接");
+          break;
+        case false:
+          if (curPlsStats.status !== "notReady") {
+            updateStatusEl(acIdConn, atIdConn, "FAILED", "连接失败");
+          } else {
+            updateStatusEl(acIdConn, atIdConn, "PENDING", "等待启动");
+          }
+          break;
+      }
+
+      if (curPlsStats.version && curPlsStats.version !== "未知") {
+        const versionTextEl = document.getElementById(
+          "acs-bc-psp-version-text"
+        );
+        versionTextEl.textContent = "v" + curPlsStats.version;
+      }
+    },
+
+    refreshPlsStatus: async (init = false) => {
+      const binExistsRet = await ipcRenderer.invoke(
+        `${IPC_METHOD_BASE}.getPlsBinExists`
+      );
+      if (binExistsRet.success && binExistsRet.data.isExists) {
+        lifecycleStatus.installed = true;
+        global.__HUGO_AURA__.plsStats.installed = true;
+        ipcRenderer.invoke(
+          `${IPC_METHOD_BASE}.updatePlsStats`,
+          global.__HUGO_AURA__.plsStats
+        );
+      } else {
+        lifecycleStatus.installed = false;
+        global.__HUGO_AURA__.plsStats.installed = false;
+        ipcRenderer.invoke(
+          `${IPC_METHOD_BASE}.updatePlsStats`,
+          global.__HUGO_AURA__.plsStats
+        );
+        global.__HUGO_AURA_UI_FUNCTIONS__.subConfig.plsStatus.updateToast(
+          "error",
+          "请下载 PLS 内核以继续",
+          null,
+          true,
+          true,
+          3000
+        );
+        global.__HUGO_AURA_UI_FUNCTIONS__.subConfig.plsStatus.updateStatusContent();
+        return;
+      }
+
+      const isDetachedRet = await ipcRenderer.invoke(
+        `${IPC_METHOD_BASE}.plsLifecycleQuery`,
+        { target: "isDetached" }
+      );
+      if (isDetachedRet.success && isDetachedRet.result) {
+        lifecycleStatus.detached = true;
+      } else {
+        lifecycleStatus.detached = false;
+      }
+
+      const isSvcInstalledRet = await ipcRenderer.invoke(
+        `${IPC_METHOD_BASE}.plsLifecycleQuery`,
+        { target: "isSvcInstalled" }
+      );
+      if (isSvcInstalledRet.success && isSvcInstalledRet.result) {
+        lifecycleStatus.svcInstalled = true;
+      } else {
+        lifecycleStatus.svcInstalled = false;
+      }
+
+      const isSvcRunningRet = await ipcRenderer.invoke(
+        `${IPC_METHOD_BASE}.plsLifecycleQuery`,
+        { target: "isSvcStart" }
+      );
+      if (isSvcRunningRet.success && isSvcRunningRet.result) {
+        lifecycleStatus.svcRunning = true;
+      } else {
+        lifecycleStatus.svcRunning = false;
+      }
+
+      if (init) {
+        global.__HUGO_AURA_UI_FUNCTIONS__.subConfig.plsStatus.updateStatusContent();
+        return;
+      }
+
+      const updateOperationBtnStatus =
+        global.__HUGO_AURA_UI_FUNCTIONS__.subConfig.plsStatus
+          .updateOperationBtnStatus;
+      updateOperationBtnStatus("Refresh", true);
+      const result = await ipcRenderer.invoke(
+        `${IPC_METHOD_BASE}.retryPlsConnect`
+      );
+      if (result.success && result.status === "Retrying") {
+        updateOperationBtnStatus("Refresh", true, "正在重连");
+
+        ipcRenderer.once(
+          `${IPC_METHOD_BASE}.post.updateRetryStatus`,
+          async (_evt, arg) => {
+            await global.__HUGO_AURA_GLOBAL__.utils.sleep(50);
+            updateOperationBtnStatus("Refresh", false, "刷新状态");
+            global.__HUGO_AURA_UI_FUNCTIONS__.subConfig.plsStatus.updateToast(
+              arg.success ? "success" : "error",
+              arg.success ? "更新成功" : "连接失败",
+              null,
+              true,
+              true,
+              3000
+            );
+            global.__HUGO_AURA_UI_FUNCTIONS__.subConfig.plsStatus.updateStatusContent();
+          }
+        );
+      } else if (result.success && result.status === "Already") {
+        updateOperationBtnStatus("Refresh", false, "刷新状态");
+        global.__HUGO_AURA_UI_FUNCTIONS__.subConfig.plsStatus.updateToast(
+          "success",
+          "更新成功",
+          null,
+          true,
+          true,
+          3000
+        );
+      }
+    },
+
+    /**
+     *
+     * @param {boolean} isShow
+     */
+    switchPBarShowStatus: (isShow) => {
+      const operAreaEl = document.getElementsByClassName(
+        "acs-bc-psp-operations-container"
+      )[0];
+      const pBarAreaEl = document.getElementsByClassName(
+        "acs-bc-psp-download-progress-area"
+      )[0];
+      const pBarDescEl = document.getElementById("acsBcPspDownloadPbarDesc");
+      const pBarSelfEl = document.getElementById("acsBcPspDownloadPbarEl");
+
+      if (isShow) {
+        pBarAreaEl.classList.remove("acs-bc-psp-dl-pbar-hidden");
+        operAreaEl.classList.add("acs-bc-psp-oper-ctnr-hidden");
+        pBarDescEl.textContent = "等待中...";
+        pBarSelfEl.style["width"] = "0";
+      } else {
+        pBarAreaEl.classList.add("acs-bc-psp-dl-pbar-hidden");
+        operAreaEl.classList.remove("acs-bc-psp-oper-ctnr-hidden");
+      }
+
+      return true;
+    },
+
+    updatePBarStatus: async (
+      progress = null,
+      desc = null,
+      type = null,
+      isCancelShown = null
+    ) => {
+      const pBarDescEl = document.getElementById("acsBcPspDownloadPbarDesc");
+      const pBarSelfEl = document.getElementById("acsBcPspDownloadPbarEl");
+      const pBarBtnEl = document.getElementById(
+        "acsBcPspDownloadPbarCancelBtn"
+      );
+      if (progress) {
+        pBarSelfEl.style["width"] = `${progress}%`;
+      }
+
+      if (type) {
+        pBarSelfEl.classList.remove("bg-success");
+        pBarSelfEl.classList.remove("bg-warning");
+        pBarSelfEl.classList.remove("bg-danger");
+        if (type !== "normal") {
+          pBarSelfEl.classList.add(`bg-${type}`);
+        }
+      }
+
+      if (desc) {
+        pBarDescEl.innerHTML = desc;
+      }
+
+      if (isCancelShown !== null) {
+        if (isCancelShown) {
+          pBarBtnEl.classList.remove("hidden");
+        } else {
+          pBarBtnEl.classList.add("hidden");
+        }
+      }
+    },
+
+    downloadPLSBin: async (retrieveMode = false) => {
+      const GLOBAL_FUNCTIONS =
+        global.__HUGO_AURA_UI_FUNCTIONS__.subConfig.plsStatus;
+      const CUR_CHANNEL = `${IPC_METHOD_BASE}.post.reportPlsDownloadStatus`;
+
+      if (!retrieveMode) {
+        GLOBAL_FUNCTIONS.updateOperationBtnStatus("Download", true, "正在检查");
+        GLOBAL_FUNCTIONS.updateOperationBtnStatus("Refresh", true);
+        await ipcRenderer.invoke(`${IPC_METHOD_BASE}.ensurePlsInstallDir`);
+        GLOBAL_FUNCTIONS.updateToast(
+          "info",
+          "准备开始下载...",
+          null,
+          true,
+          true,
+          2000
+        );
+        GLOBAL_FUNCTIONS.updateOperationBtnStatus("Download", true);
+      } else {
+        GLOBAL_FUNCTIONS.updateToast(
+          "info",
+          "正在恢复下载状态",
+          null,
+          true,
+          true,
+          2000
+        );
+      }
+
+      GLOBAL_FUNCTIONS.switchPBarShowStatus(true);
+      GLOBAL_FUNCTIONS.updatePBarStatus(0, "等待中...", "normal", false);
+
+      const callbackFn = (_evt, info) => {
+        switch (info.status) {
+          case "failed":
+            GLOBAL_FUNCTIONS.updateToast(
+              "error",
+              "下载失败",
+              `<p>${
+                info.message ? info.message : "检查日志以获取错误信息"
+              }</p><p>
+              ${info.errorObj ? info.errorObj : ""}
+              </p>`,
+              true,
+              true,
+              5000
+            );
+
+            GLOBAL_FUNCTIONS.updatePBarStatus(
+              100,
+              "下载时发生错误",
+              "danger",
+              false
+            );
+            setTimeout(() => {
+              GLOBAL_FUNCTIONS.switchPBarShowStatus(false);
+            }, 1000);
+
+            ipcRenderer.off(CUR_CHANNEL, callbackFn);
+            GLOBAL_FUNCTIONS.updateOperationBtnStatus("Refresh", false);
+            GLOBAL_FUNCTIONS.updateOperationBtnStatus(
+              "Download",
+              false,
+              "下载内核"
+            );
+            break;
+          case "done":
+            GLOBAL_FUNCTIONS.updateToast(
+              "success",
+              "下载成功",
+              null,
+              true,
+              true,
+              2500
+            );
+
+            GLOBAL_FUNCTIONS.updatePBarStatus(
+              100,
+              "下载成功",
+              "success",
+              false
+            );
+            setTimeout(() => {
+              GLOBAL_FUNCTIONS.switchPBarShowStatus(false);
+            }, 1000);
+
+            ipcRenderer.off(CUR_CHANNEL, callbackFn);
+            GLOBAL_FUNCTIONS.updateOperationBtnStatus("Refresh", false);
+            GLOBAL_FUNCTIONS.updateOperationBtnStatus(
+              "Download",
+              true,
+              "下载内核"
+            );
+            lifecycleStatus.installed = true;
+            global.__HUGO_AURA__.plsStats.installed = true;
+            ipcRenderer.invoke(
+              `${IPC_METHOD_BASE}.updatePlsStats`,
+              global.__HUGO_AURA__.plsStats
+            );
+            GLOBAL_FUNCTIONS.updateStatusContent();
+            break;
+          case "waiting":
+            GLOBAL_FUNCTIONS.updatePBarStatus(0, "正在连接", "normal");
+            if (
+              !global.__HUGO_AURA_UI_REACTIVES__.subConfig.plsStatus
+                .curDlTaskId ||
+              global.__HUGO_AURA_UI_REACTIVES__.subConfig.plsStatus
+                .curDlTaskId !== info.id
+            ) {
+              global.__HUGO_AURA_UI_REACTIVES__.subConfig.plsStatus.curDlTaskId =
+                info.id;
+            }
+            break;
+          case "progressing":
+            const roundProgress = Math.round(info.progress);
+            GLOBAL_FUNCTIONS.updatePBarStatus(
+              roundProgress,
+              `正在下载中... ${roundProgress}% (${(
+                info.curBytes /
+                1024 /
+                1024
+              ).toFixed(2)}MB / ${(info.totalBytes / 1024 / 1024).toFixed(
+                2
+              )}MB)`, // POWERED BY PRETTIER
+              "normal",
+              true
+            );
+            break;
+          case "struggling":
+            GLOBAL_FUNCTIONS.updatePBarStatus(100, info.message, "warning");
+            break;
+          case "cancelled":
+            GLOBAL_FUNCTIONS.updateOperationBtnStatus("Refresh", false);
+            GLOBAL_FUNCTIONS.updateOperationBtnStatus(
+              "Download",
+              false,
+              "下载内核"
+            );
+            break;
+        }
+      };
+
+      ipcRenderer.on(CUR_CHANNEL, callbackFn);
+
+      ipcRenderer.invoke(`${IPC_METHOD_BASE}.downloadPls`, {
+        channel: "stable",
+        reportTo: "assistant",
+      });
+    },
+
+    cancelDownloadTask: async () => {
+      const taskId =
+        global.__HUGO_AURA_UI_REACTIVES__.subConfig.plsStatus.curDlTaskId;
+
+      if (!taskId) {
+        GLOBAL_FUNCTIONS.updateToast(
+          "error",
+          "操作取消失败",
+          "<p>未能获取当前的下载任务 ID</p>",
+          true,
+          true,
+          3000
+        );
+        return false;
+      }
+
+      const result = await ipcRenderer.invoke(
+        "$aura.fs.dl.cancelDownloadTask",
+        { targetTaskId: taskId }
+      );
+
+      if (result.success) {
+        GLOBAL_FUNCTIONS.updateToast(
+          "success",
+          "操作取消成功",
+          null,
+          true,
+          true,
+          2000
+        );
+        GLOBAL_FUNCTIONS.switchPBarShowStatus(false);
+        return true;
+      } else {
+        GLOBAL_FUNCTIONS.updateToast(
+          "error",
+          "操作取消失败",
+          `<p>错误代码: ${result.error}</p>`,
+          true,
+          true,
+          3000
+        );
+        return false;
+      }
+    },
+  };
+
+  const GLOBAL_FUNCTIONS =
+    global.__HUGO_AURA_UI_FUNCTIONS__.subConfig.plsStatus;
+
   const {
     updatePlsStatusFromLocal,
   } = require(`${REQUIRE_BASE}/../../../composables/plsConfigManager`);
 
+  const initBsTooltip = () => {
+    const tooltipTriggerList = document.querySelectorAll(
+      '[data-bs-toggle="tooltip"]'
+    );
+    const _tooltipList = [...tooltipTriggerList].map(
+      (tooltipTriggerEl) => new bootstrap.Tooltip(tooltipTriggerEl)
+    );
+  };
+
   const updateStatusEl = (
     areaContainerId,
     areaTextId,
@@ -30,6 +854,9 @@
         areaContainerEl.className =
           "acs-bc-pls-status-page-status-area warning";
         break;
+      case "INFO":
+        areaContainerEl.className = "acs-bc-pls-status-page-status-area info";
+        break;
       default:
         return false;
     }
@@ -37,49 +864,19 @@
     return true;
   };
 
-  const updateStatus = async () => {
-    const curPlsStats = await updatePlsStatusFromLocal();
-
-    const acIdInst = "acs-bc-psp-installStatus-container";
-    const atIdInst = "acs-bc-psp-installStatus-text";
-    switch (curPlsStats.installed) {
-      case true:
-        updateStatusEl(acIdInst, atIdInst, "SUCCESS", "已安装");
-        break;
-      case false:
-        updateStatusEl(acIdInst, atIdInst, "PENDING", "未安装");
-    }
-
-    const acIdLaunch = "acs-bc-psp-launchStatus-container";
-    const atIdLaunch = "acs-bc-psp-launchStatus-text";
-    switch (curPlsStats.launched) {
-      case true:
-        updateStatusEl(acIdLaunch, atIdLaunch, "SUCCESS", "已启动");
-        break;
-      case false:
-        updateStatusEl(acIdLaunch, atIdLaunch, "PENDING", "未启动");
-        break;
-    }
-
-    const acIdConn = "acs-bc-psp-connStatus-container";
-    const atIdConn = "acs-bc-psp-connStatus-text";
-    switch (curPlsStats.connected) {
-      case true:
-        updateStatusEl(acIdConn, atIdConn, "SUCCESS", "已连接");
-        break;
-      case false:
-        updateStatusEl(acIdConn, atIdConn, "FAILED", "连接失败");
-        break;
-    }
-
-    if (curPlsStats.version && curPlsStats.version !== "未知") {
-      const versionTextEl = document.getElementById("acs-bc-psp-version-text");
-      versionTextEl.textContent = "v" + curPlsStats.version;
-    }
-  };
-
   const onMounted = () => {
-    updateStatus();
+    initBsTooltip();
+    GLOBAL_FUNCTIONS.updateOperationBtnStatus("Refresh", false);
+    GLOBAL_FUNCTIONS.refreshPlsStatus(true);
+
+    const eventListener = () => {
+      GLOBAL_FUNCTIONS.updateStatusContent();
+    };
+    document.addEventListener("onPLSStatsUpdate", eventListener);
+    global.__HUGO_AURA_GLOBAL__.utils.createOnLeaveEvtListener(
+      "onPLSStatsUpdate",
+      eventListener
+    );
   };
 
   onMounted();

src/aura/ui/pages/configSubPages/behaviourCtrl/settings/basic.js

@@ -4,6 +4,28 @@ const {
   updatePlsConfigToRemote,
 } = require(`${REQUIRE_BASE}/../../../../composables/plsConfigManager`);
 
+const reusableChkFn = {
+  checkRelativePath: () => {
+    if (newVal === "" || !newVal)
+      return { valid: false, hint: "请输入证书路径" };
+
+    if (newVal.includes(":/") || newVal.includes(":\\")) {
+      return { valid: false, hint: "请输入相对路径, 而非绝对路径" };
+    }
+
+    if (newVal.includes("\\")) {
+      return {
+        valid: false,
+        hint: '请输入正确的路径, 使用 "/" 作为路径符',
+      };
+    }
+
+    return {
+      valid: true,
+    };
+  },
+};
+
 const basicSettings = [
   {
     id: 0,
@@ -11,33 +33,140 @@ const basicSettings = [
     child: [
       {
         index: 0,
-        id: "authToken",
+        id: "plsListenPort",
         type: "input",
-        subType: "text",
-        name: "WebSocket 认证密钥",
-        description: "选择一个安全的密钥, 用于 PLS 侧验证 Aura 前端身份",
-        restart: true,
+        subType: "number",
+        name: "PLS WS 默认监听端口",
+        description: "PLS 的 WebSocket 服务器将默认监听指定的端口",
+        reactive: true,
+        reactiveVal: ["root.settings"],
+        restart: false,
         reload: false,
+        PLSRequired: true,
         restartPLS: false,
+        warning: true,
+        warningContent: "PLS 仍会在默认端口被占用时, 自动随机端口重试",
         associateVal: null,
         auraIf: () => true,
         defaultValue: "",
-        placeHolder: "输入一个密钥",
+        placeHolder: "输入端口号 (10000 ~ 65535)",
         valueGetter: () => {
-          return global.__HUGO_AURA_CONFIG__.plsToken;
+          if (!global.__HUGO_AURA__.plsSettings) return "";
+          return global.__HUGO_AURA__.plsSettings.wsPort;
         },
         callbackFn: (newVal) => {
           if (newVal === "" || !newVal)
-            return { valid: false, hint: "请输入认证密钥" };
+            return { valid: false, hint: "请输入端口号" };
 
-          if (newVal.length < 8) {
-            return { valid: false, hint: "至少输入 8 位字符" };
+          const numberNewVal = Number(newVal);
+          if (numberNewVal === NaN || !(10000 <= numberNewVal) || !(newVal <= 65535)) {
+            return { valid: false, hint: "请输入合法的端口号 (10000 ~ 65535)" };
           }
 
-          global.__HUGO_AURA_CONFIG__.plsToken = newVal;
+          global.__HUGO_AURA__.plsSettings.wsPort = numberNewVal;
+          updatePlsConfigToRemote("wsPort", numberNewVal);
           return { valid: true };
         },
       },
+      {
+        index: 1,
+        id: "plsCertPath",
+        type: "input",
+        subType: "text",
+        name: "WSS TLS 证书相对路径",
+        description: "PLS 将使用指定路径下的证书启动 WSS 服务器",
+        reactive: true,
+        reactiveVal: ["root.settings"],
+        restart: false,
+        reload: false,
+        PLSRequired: true,
+        restartPLS: true,
+        tip: true,
+        tipTitle:
+          '路径相对于 "%PROGRAMDATA%\\HugoAura\\Aura-PLS\\", 使用 "/" 作为路径符',
+        associateVal: null,
+        auraIf: () => true,
+        defaultValue: "",
+        placeHolder: "输入相对路径, 例如: config/vme50/cert.crt",
+        valueGetter: () => {
+          if (!global.__HUGO_AURA__.plsSettings) return "";
+          return global.__HUGO_AURA__.plsSettings.certPath;
+        },
+        callbackFn: (newVal) => {
+          const validate = reusableChkFn.checkRelativePath();
+          if (!validate.valid) {
+            return validate;
+          }
+
+          global.__HUGO_AURA__.plsSettings.certPath = newVal;
+          updatePlsConfigToRemote("certPath", newVal);
+          return { valid: true };
+        },
+      },
+      {
+        index: 2,
+        id: "plsCertPath",
+        type: "input",
+        subType: "text",
+        name: "WSS TLS 证书私钥相对路径",
+        description: "PLS 将使用指定路径下的私钥启动 WSS 服务器",
+        reactive: true,
+        reactiveVal: ["root.settings"],
+        restart: false,
+        reload: false,
+        PLSRequired: true,
+        restartPLS: true,
+        tip: true,
+        tipTitle:
+          '路径相对于 "%PROGRAMDATA%\\HugoAura\\Aura-PLS\\", 使用 "/" 作为路径符',
+        warning: true,
+        warningContent: "请使用 PEM 格式的密钥",
+        associateVal: null,
+        auraIf: () => true,
+        defaultValue: "",
+        placeHolder: "输入相对路径, 例如: config/vme50/cert.key",
+        valueGetter: () => {
+          if (!global.__HUGO_AURA__.plsSettings) return "";
+          return global.__HUGO_AURA__.plsSettings.keyPath;
+        },
+        callbackFn: (newVal) => {
+          const validate = reusableChkFn.checkRelativePath();
+          if (!validate.valid) {
+            return validate;
+          }
+
+          global.__HUGO_AURA__.plsSettings.keyPath = newVal;
+          updatePlsConfigToRemote("keyPath", newVal);
+          return { valid: true };
+        },
+      },
+      {
+        index: 3,
+        id: "plsRegenCertAftRelaunch",
+        type: "switch",
+        name: "重新生成 TLS 证书",
+        description: "PLS 将在下次启动时重新生成 TLS 证书",
+        reactive: true,
+        reactiveVal: ["root.settings"],
+        restart: false,
+        reload: false,
+        PLSRequired: true,
+        restartPLS: true,
+        associateVal: null,
+        auraIf: () => true,
+        defaultValue: false,
+        valueGetter: () => {
+          if (!global.__HUGO_AURA__.plsSettings) return "";
+          return global.__HUGO_AURA__.plsSettings.regenCert;
+        },
+        callbackFn: (newVal) => {
+          if (typeof newVal !== "boolean") return false;
+
+          global.__HUGO_AURA__.plsSettings.regenCert = newVal;
+          updatePlsConfigToRemote("regenCert", newVal);
+          return true;
+        },
+      },
     ],
   },
 ];

src/aura/ui/pages/configSubPages/behaviourCtrl/settings/deviceSecurity.js

@@ -0,0 +1,99 @@
+const REQUIRE_BASE = ".";
+
+const {
+  updatePlsConfigToRemote,
+} = require(`${REQUIRE_BASE}/../../../../composables/plsConfigManager`);
+
+const composables = {};
+
+const deviceSecuritySettings = [
+  {
+    id: 0,
+    categoryName: "冰点管理",
+    child: [
+      {
+        index: 0,
+        id: "enableFreezeInfoReportOverride",
+        type: "switch",
+        name: "启用冰冻状态篡改",
+        description: "篡改上报的冰冻数据, 可自定义集控端显示的状态",
+        reactive: true,
+        reactiveVal: ["root.ruleSettings"],
+        restart: false,
+        reload: false,
+        PLSRequired: true,
+        restartPLS: false,
+        associateVal: null,
+        auraIf: () => true,
+        defaultValue: false,
+        valueGetter: () => {
+          if (!global.__HUGO_AURA__.plsRules) return "";
+          return global.__HUGO_AURA__.plsRules.client.security.uploadFreezeInfo
+            .enable;
+        },
+        callbackFn: (newVal) => {
+          if (typeof newVal !== "boolean") return;
+          if (!global.__HUGO_AURA__.plsRules) return;
+
+          global.__HUGO_AURA__.plsRules.client.security.uploadFreezeInfo.enable =
+            newVal;
+          updatePlsConfigToRemote(
+            "ruleSettings.client.security.uploadFreezeInfo.enable",
+            newVal
+          );
+          return true;
+        },
+      },
+      {
+        index: 1,
+        id: "freezeInfoReportOverrideType",
+        type: "radio",
+        name: "篡改模式",
+        description:
+          "选择一种篡改模式, 选中的磁盘范围会<b>被上报</b>为冻结 (不是实际行为)",
+        restart: false,
+        reload: false,
+        PLSRequired: true,
+        restartPLS: false,
+        reactive: true,
+        reactiveVal: ["root.ruleSettings"],
+        associateVal: ["ruleSettings.client.security.uploadFreezeInfo.enable"],
+        auraIf: () => {
+          if (!global.__HUGO_AURA__.plsRules) return true;
+
+          return global.__HUGO_AURA__.plsRules.client.security.uploadFreezeInfo
+            .enable;
+        },
+        defaultValue: "allFreeze",
+        templates: ["allFreeze", "systemOnly", "exceptSecondDisk"],
+        templateLabels: ["全部冻结", "仅系统盘", "第二磁盘除外"],
+        valueGetter: () => {
+          if (!global.__HUGO_AURA__.plsRules) return;
+
+          return global.__HUGO_AURA__.plsRules.client.security.uploadFreezeInfo
+            .rewriteMode;
+        },
+        callbackFn: (newVal) => {
+          global.__HUGO_AURA__.plsRules.client.security.uploadFreezeInfo.rewriteMode =
+            newVal;
+          updatePlsConfigToRemote(
+            "ruleSettings.client.security.uploadFreezeInfo.rewriteMode",
+            newVal
+          );
+          return true;
+        },
+      },
+      {
+        index: 2,
+        id: "freezeInfoReportOverridePreview",
+        type: "preview",
+        loaderTarget:
+          "Aura.UI.Assistant.Config.BehaviourCtrl.DeviceSecurity.FreezeOverridePreview",
+        associateVal: ["ruleSettings.client.security.uploadFreezeInfo"],
+        listenerType: "pls",
+      },
+    ],
+  },
+];
+
+module.exports = { deviceSecuritySettings };

src/aura/ui/pages/configSubPages/behaviourCtrl/settings/previews/freezeOverridePreview/freezeOverridePreview.css

@@ -0,0 +1,104 @@
+.acs-bc-dsc-fop-container {
+  display: flex;
+}
+
+.acs-bc-dsc-fop-please-wait,
+.acs-bc-dsc-fop-on-req-error,
+.acs-bc-dsc-fop-on-not-bind {
+  display: flex;
+  flex-direction: row;
+  align-items: center;
+  justify-content: center;
+
+  width: 100%;
+  height: 100%;
+  opacity: 0.6;
+}
+
+.acs-bc-dsc-fop-please-wait svg,
+.acs-bc-dsc-fop-on-req-error svg,
+.acs-bc-dsc-fop-on-not-bind svg {
+  width: 18px;
+  height: 18px;
+}
+
+.acs-bc-dsc-fop-please-wait p,
+.acs-bc-dsc-fop-on-req-error p,
+.acs-bc-dsc-fop-on-not-bind p {
+  margin-left: 0.5rem;
+  margin-top: -1px;
+}
+
+.acs-bc-dsc-fop-please-wait[auraIf="false"],
+.acs-bc-dsc-fop-on-req-error[auraIf="false"],
+.acs-bc-dsc-fop-on-not-bind[auraIf="false"],
+.acs-bc-dsc-fop-main[auraIf="false"] {
+  display: none;
+}
+
+.acs-bc-dsc-fop-main {
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  align-items: center;
+  width: 100%;
+}
+
+.acs-bc-dsc-fop-main .disks-container {
+  display: flex;
+  flex-direction: row;
+}
+
+.acs-bc-dsc-fop-disk-el {
+  padding: 5px 10px;
+  border-radius: 3px;
+  border: 0.5px solid rgba(0, 0, 0, 0.25);
+  margin-left: 0.375rem;
+  margin-right: 0.375rem;
+
+  transition: all 0.5s;
+  /* 没有用, 因为元素全被重新创建了 */
+}
+
+.acs-bc-dsc-fop-disk-el.active {
+  background-color: #1d70f2;
+  color: white;
+  border: 0.5px solid rgba(0, 0, 0, 0.125);
+}
+
+.acs-bc-dsc-fop-disk-el.active:hover {
+  background-color: #4e8df2;
+}
+
+.acs-bc-dsc-fop-main-hint-area {
+  display: flex;
+  flex-direction: row;
+  margin-top: 1rem;
+  margin-bottom: -0.25rem;
+}
+
+.acs-bc-dsc-fop-main-hint-area svg {
+  width: 18px;
+  height: 18px;
+}
+
+.acs-bc-dsc-fop-main-hint-area div {
+  display: flex;
+  flex-direction: row;
+  justify-content: center;
+  align-items: center;
+}
+
+.acs-bc-dsc-fop-main-hint-area p {
+  margin-top: -1px;
+  margin-left: 0.25rem;
+}
+
+.acs-bc-dsc-fop-main-hint-area .acs-bc-dsc-fop-main-hint-freeze {
+  margin-right: 0.5rem;
+  color: #1d70f2;
+}
+
+.acs-bc-dsc-fop-main-hint-area .acs-bc-dsc-fop-main-hint-unfreeze {
+  margin-left: 0.5rem;
+}

src/aura/ui/pages/configSubPages/behaviourCtrl/settings/previews/freezeOverridePreview/freezeOverridePreview.html

@@ -0,0 +1,91 @@
+<div class="acs-bc-dsc-fop-container">
+  <div class="acs-bc-dsc-fop-please-wait" auraIf="true">
+    <svg
+      xmlns="http://www.w3.org/2000/svg"
+      width="32"
+      height="32"
+      viewBox="0 0 32 32"
+    >
+      <path
+        fill="currentColor"
+        d="M16 30a14 14 0 1 1 14-14a14 14 0 0 1-14 14m0-26a12 12 0 1 0 12 12A12 12 0 0 0 16 4"
+      />
+      <path fill="currentColor" d="M20.59 22L15 16.41V7h2v8.58l5 5.01z" />
+    </svg>
+
+    <p>请稍候...</p>
+  </div>
+
+  <div class="acs-bc-dsc-fop-on-req-error" auraIf="false">
+    <svg
+      xmlns="http://www.w3.org/2000/svg"
+      width="32"
+      height="32"
+      viewBox="0 0 32 32"
+    >
+      <path fill="currentColor" d="M9 10.555L10.555 9L23 21.444L21.444 23z" />
+      <path
+        fill="currentColor"
+        d="M16 2A13.914 13.914 0 0 0 2 16a13.914 13.914 0 0 0 14 14a13.914 13.914 0 0 0 14-14A13.914 13.914 0 0 0 16 2m0 26a12 12 0 1 1 12-12a12.035 12.035 0 0 1-12 12"
+      />
+    </svg>
+
+    <p>获取磁盘信息失败: <font id="acsBcDscFopOnReqErrorDetail"></font></p>
+  </div>
+
+  <div class="acs-bc-dsc-fop-on-not-bind" auraIf="false">
+    <svg
+      xmlns="http://www.w3.org/2000/svg"
+      width="32"
+      height="32"
+      viewBox="0 0 32 32"
+    >
+      <path
+        fill="currentColor"
+        d="M31.324 11.261A14.27 14.27 0 0 0 22.25 8H22v2h.25c2.608 0 5.155.837 7.246 2.372a12.18 12.18 0 0 1-7.548 7.036q.052-.605.052-1.22C22 10.366 15.635 4 7.812 4c-.929 0-1.856.09-2.757.268l-.657.13l-.13.657A14.3 14.3 0 0 0 4 7.812c0 4.124 1.78 7.831 4.598 10.426A14.2 14.2 0 0 0 8 22.254l.001.001a14.27 14.27 0 0 0 3.261 9.07l.439.53l.652-.22a14.18 14.18 0 0 0 9.237-10.046a14.18 14.18 0 0 0 10.045-9.237l.22-.652zM12.372 29.496A12.27 12.27 0 0 1 10 22.251c0-.912.113-1.796.303-2.652a14.1 14.1 0 0 0 9.105 2.349a12.18 12.18 0 0 1-7.036 7.548m7.51-9.613q-.833.116-1.694.117c-2.715 0-5.218-.904-7.247-2.412a12.4 12.4 0 0 1 4.048-5.204l-1.28-1.53A14.3 14.3 0 0 0 9.37 16.2A12.14 12.14 0 0 1 6.117 6.117A12 12 0 0 1 7.812 6C14.532 6 20 11.468 20 18.188q0 .862-.117 1.695Z"
+      />
+      <circle cx="20" cy="2" r="2" fill="currentColor" />
+      <circle cx="27" cy="26" r="2" fill="currentColor" />
+      <circle cx="2" cy="20" r="2" fill="currentColor" />
+    </svg>
+
+    <p>当前设备暂未绑定学校, 无法查询冰点信息</p>
+  </div>
+
+  <div class="acs-bc-dsc-fop-main" auraIf="false">
+    <div class="disks-container">
+      <p class="acs-bc-dsc-fop-disk-el">C 盘</p>
+    </div>
+
+    <div class="acs-bc-dsc-fop-main-hint-area">
+      <div class="acs-bc-dsc-fop-main-hint-freeze">
+        <svg
+          xmlns="http://www.w3.org/2000/svg"
+          width="32"
+          height="32"
+          viewBox="0 0 32 32"
+        >
+          <path
+            fill="currentColor"
+            d="M21.415 12H28v-2h-4.585L28 5.415L26.586 4L22 8.587V4h-2v6.587L18.587 12H17V8h-2v4h-1.587L12 10.587V4h-2v4.587L5.414 4L4 5.415L8.585 10H4v2h6.585L12 13.415V15H8v2h4v1.587L10.587 20H4v2h4.587L4 26.586l1.414 1.415L10 23.415V28h2v-6.585L13.415 20H15v4h2v-4h1.585L20 21.415V28h2v-4.585l4.585 4.586L28 26.586L23.413 22H28v-2h-6.587L20 18.587V17h4v-2h-4v-1.585ZM18 18h-4v-4h4Z"
+          />
+        </svg>
+        <p>已冻结</p>
+      </div>
+      <div class="acs-bc-dsc-fop-main-hint-unfreeze">
+        <svg
+          xmlns="http://www.w3.org/2000/svg"
+          width="32"
+          height="32"
+          viewBox="0 0 32 32"
+        >
+          <path
+            fill="currentColor"
+            d="M16 12.005a4 4 0 1 1-4 4a4.005 4.005 0 0 1 4-4m0-2a6 6 0 1 0 6 6a6 6 0 0 0-6-6M5.394 6.813L6.81 5.399l3.505 3.506L8.9 10.319zM2 15.005h5v2H2zm3.394 10.193L8.9 21.692l1.414 1.414l-3.505 3.506zM15 25.005h2v5h-2zm6.687-1.9l1.414-1.414l3.506 3.506l-1.414 1.414zm3.313-8.1h5v2h-5zm-3.313-6.101l3.506-3.506l1.414 1.414l-3.506 3.506zM15 2.005h2v5h-2z"
+          />
+        </svg>
+        <p>未冻结</p>
+      </div>
+    </div>
+  </div>
+</div>

src/aura/ui/pages/configSubPages/behaviourCtrl/settings/previews/freezeOverridePreview/freezeOverridePreview.js

@@ -0,0 +1,156 @@
+// @ts-check
+
+(() => {
+  const REQUIRE_BASE = "../..";
+  const { genRandomHex } = require(`${REQUIRE_BASE}/aura/utils/crypto`);
+
+  const composables = {
+    getAndUpdateDiskInfo: async (curConfig) => {
+      const progressingEl = document.getElementsByClassName(
+        "acs-bc-dsc-fop-please-wait"
+      )[0];
+      const onErrorEl = document.getElementsByClassName(
+        "acs-bc-dsc-fop-on-req-error"
+      )[0];
+      const onNotBindEl = document.getElementsByClassName(
+        "acs-bc-dsc-fop-on-not-bind"
+      )[0];
+      const mainEl = document.getElementsByClassName("acs-bc-dsc-fop-main")[0];
+      const diskContainerEl =
+        document.getElementsByClassName("disks-container")[0];
+
+      const seewoProxyPort = window._ACCEPT_DATA.data.ports.SeewoProxyHTTP;
+
+      const reqPromise = new Promise((resolve) => {
+        fetch(
+          `https://127.0.0.1:${seewoProxyPort}/forward/freeze/api/v1/get_disk_data`,
+          {
+            headers: {
+              accept: "application/json, text/plain, */*",
+              "X-Auth-Traceid": genRandomHex(),
+            },
+          }
+        )
+          .then(async (response) => {
+            const parsedData = await response.json();
+
+            resolve({
+              success: true,
+              data: parsedData,
+              status: response.status,
+            });
+          })
+          .catch((e) => {
+            resolve({ success: false, data: null, errorObj: e });
+          });
+      });
+
+      const responseInfo = await reqPromise;
+
+      progressingEl.setAttribute("auraIf", "false");
+
+      if (!responseInfo.success) {
+        onNotBindEl.setAttribute("auraIf", "false");
+        mainEl.setAttribute("auraIf", "false");
+        onErrorEl.setAttribute("auraIf", "true");
+        const detailEl = document.getElementById("acsBcDscFopOnReqErrorDetail");
+        // @ts-expect-error
+        detailEl.textContent = responseInfo.errorObj;
+
+        return;
+      }
+
+      if (responseInfo.status !== 200) {
+        onErrorEl.setAttribute("auraIf", "false");
+        mainEl.setAttribute("auraIf", "false");
+        onNotBindEl.setAttribute("auraIf", "true");
+        return;
+      }
+
+      diskContainerEl.innerHTML = ``;
+
+      const curDisks = [];
+      for (const disk of responseInfo.data.data[0].disksData) {
+        curDisks.push({ name: disk.diskName, status: disk.protectedStatus });
+      }
+
+      const diskElTemplate = document.createElement("p");
+      diskElTemplate.classList.add("acs-bc-dsc-fop-disk-el");
+      if (!curConfig.enable) {
+        for (const disk of curDisks) {
+          const curDiskEl = diskElTemplate.cloneNode();
+          if (disk.status !== 0) {
+            // @ts-expect-error
+            curDiskEl.classList.add("active");
+          }
+          curDiskEl.textContent = `${disk.name.toUpperCase()} 盘`;
+          diskContainerEl.appendChild(curDiskEl);
+        }
+      } else {
+        switch (curConfig.rewriteMode) {
+          case "allFreeze":
+            {
+              for (const disk of curDisks) {
+                const curDiskEl = diskElTemplate.cloneNode();
+                // @ts-expect-error
+                curDiskEl.classList.add("active");
+                curDiskEl.textContent = `${disk.name.toUpperCase()} 盘`;
+                diskContainerEl.appendChild(curDiskEl);
+              }
+            }
+            break;
+          case "systemOnly":
+            {
+              let idx = 0;
+              for (const disk of curDisks) {
+                const curDiskEl = diskElTemplate.cloneNode();
+                // @ts-expect-error
+                if (idx === 0) curDiskEl.classList.add("active");
+                curDiskEl.textContent = `${disk.name.toUpperCase()} 盘`;
+                diskContainerEl.appendChild(curDiskEl);
+                idx += 1;
+              }
+            }
+            break;
+          case "exceptSecondDisk":
+            {
+              let idx = 0;
+              for (const disk of curDisks) {
+                const curDiskEl = diskElTemplate.cloneNode();
+                // @ts-expect-error
+                if (idx === 0) curDiskEl.classList.add("active");
+                curDiskEl.textContent = `${disk.name.toUpperCase()} 盘`;
+                diskContainerEl.appendChild(curDiskEl);
+                idx += 1;
+              }
+            }
+            break;
+        }
+      }
+
+      onErrorEl.setAttribute("auraIf", "false");
+      onNotBindEl.setAttribute("auraIf", "false");
+      mainEl.setAttribute("auraIf", "true");
+    },
+  };
+
+  const onMounted = () => {
+    const rootEl = document.getElementsByClassName(
+      "acs-bc-dsc-fop-container"
+    )[0];
+
+    const eventListener = (_event) => {
+      if (!global.__HUGO_AURA__.plsRules) return;
+      composables.getAndUpdateDiskInfo(
+        global.__HUGO_AURA__.plsRules.client.security.uploadFreezeInfo
+      );
+    };
+    rootEl.addEventListener("onAssociateValueUpdated", eventListener);
+
+    setTimeout(() => {
+      eventListener();
+    }, 100);
+  };
+
+  onMounted();
+})();

src/aura/ui/pages/configSubPages/disableLimitations/settings/audit.js

@@ -8,7 +8,8 @@ const banAuditSettings = [
         id: "disableFridayReport",
         type: "switch",
         name: "禁用 Friday 错误统计",
-        description: "重置 CVTE 的 Friday 错误收集服务载入 URL, 避免意外的信息上传",
+        description:
+          "重置 CVTE 的 Friday 错误收集服务载入 URL, 避免意外的信息上传",
         restart: true,
         reload: false,
         associateVal: null,
@@ -39,7 +40,8 @@ const banAuditSettings = [
         restart: true,
         reload: false,
         tip: true,
-        tipTitle: '启用后, 可能造成部分操作出现较长延迟 (如冰点操作)。希沃管家会尝试五次上报, 均失败后才会进行下一步操作',
+        tipTitle:
+          "启用后, 可能造成部分操作出现较长延迟 (如冰点操作)。希沃管家会尝试五次上报, 均失败后才会进行下一步操作",
         associateVal: null,
         auraIf: () => true,
         defaultValue: false,

src/aura/ui/pages/configSubPages/disableLimitations/settings/auth.js

@@ -225,8 +225,8 @@ const authSettings = [
         auraIf: () => {
           return (
             global.__HUGO_AURA_CONFIG__.rewrite["vendor/screenLock"].enabled &&
-            global.__HUGO_AURA_CONFIG__.rewrite["vendor/screenLock"].authRewriteType ===
-              "customActivationCode"
+            global.__HUGO_AURA_CONFIG__.rewrite["vendor/screenLock"]
+              .authRewriteType === "customActivationCode"
           );
         },
         defaultValue: "",

src/aura/ui/pages/configSubPages/preferences/settings/aura.js

@@ -1,3 +1,162 @@
+// @ts-check
+
+const functions = {
+  /**
+   *
+   * @param {"enc" | "update"} mode
+   * @param {SHA256EncryptedPassword | null} password
+   */
+  handleEnableConfigEncryption: async (mode, password) => {
+    let exiPassword = "";
+    if (!password) {
+      exiPassword =
+        global.__HUGO_AURA_CONFIG__.auraSettings.settingsPasswordWithSalt;
+    }
+
+    switch (mode) {
+      case "enc":
+        ipcRenderer.invoke("$aura.config.setConfigEncSettings", {
+          target: true,
+        });
+        global.ipcRenderer.invoke("$aura.config.dispatchConfigFromRenderer", {
+          data: JSON.stringify(global.__HUGO_AURA_CONFIG__),
+        });
+        global.__HUGO_AURA_CONFIG_MGR__.encryptConfig(
+          global.__HUGO_AURA_CONFIG__,
+          password ? password : exiPassword
+        );
+        global.__HUGO_AURA_CONFIG_MGR__.saveEncPassword(
+          password ? password : exiPassword
+        );
+        break;
+      case "update":
+        const result = await global.__HUGO_AURA_CONFIG_MGR__.switchToDecConfig(
+          global.__HUGO_AURA_CONFIG__,
+          null
+        );
+        if (result.success) {
+          ipcRenderer.invoke("$aura.config.setConfigEncSettings", {
+            target: true,
+          });
+          global.ipcRenderer.invoke("$aura.config.dispatchConfigFromRenderer", {
+            data: JSON.stringify(global.__HUGO_AURA_CONFIG__),
+          });
+          global.__HUGO_AURA_CONFIG_MGR__.encryptConfig(
+            global.__HUGO_AURA_CONFIG__,
+            password ? password : exiPassword
+          );
+          global.__HUGO_AURA_CONFIG_MGR__.saveEncPassword(
+            password ? password : exiPassword
+          );
+        } else {
+          // TODO: Error handling
+        }
+        break;
+    }
+  },
+
+  /**
+   *
+   * @param {SHA256EncryptedPassword} password
+   */
+  handle2ndPasswordPrompt: async (password) => {
+    const acsDialogAreaEl = document.getElementsByClassName(
+      "aura-config-page-auth-dialog-area"
+    )[0];
+    const acpAppBarEl = document.getElementsByClassName(
+      "aura-config-page-header-area"
+    )[0];
+    const acpDialogTitleEl = document.getElementsByClassName(
+      "acp-auth-dialog-title"
+    )[0];
+    const acpDialogConfirmBtnEl = document.getElementsByClassName(
+      "acp-auth-confirm-btn"
+    )[0];
+    const acpDialogCancelBtnEl = document.getElementsByClassName(
+      "acp-auth-cancel-btn"
+    )[0];
+    // @ts-expect-error
+    acsDialogAreaEl.style = "";
+    acpDialogTitleEl.textContent = "请再次输入密码";
+    await window.__HUGO_AURA_GLOBAL__.utils.sleep(50);
+    acpAppBarEl.classList.add("color-reverse");
+    acsDialogAreaEl.classList.remove("acp-ada-hidden");
+
+    const showFailedAnimation = async (el) => {
+      el.classList.remove("invalid");
+      await window.__HUGO_AURA_GLOBAL__.utils.sleep(50);
+      el.classList.add("invalid"); // Custom Anim
+      el.classList.add("is-invalid"); // Bootstrap
+    };
+
+    let resolveFn = null;
+    const awaitCompletePromise = new Promise((resolve) => {
+      resolveFn = resolve;
+    });
+
+    const handleExit = async () => {
+      const result = await awaitCompletePromise;
+      console.debug(result);
+      if (result) {
+        console.debug("ret true");
+        return { valid: true };
+      } else {
+        console.debug("ret false");
+        const inputEl = document.getElementById("auraSettingsPasswd");
+        // @ts-expect-error
+        inputEl.value = "";
+        return { valid: false, hint: "未能验证密码, 请重试" };
+      }
+    };
+
+    const verifyPassword = async (_clickEvt) => {
+      const inputEl = document.getElementById("acp-auth-user-input");
+      const acpDialogTitleEl = document.getElementsByClassName(
+        "acp-auth-dialog-title"
+      )[0];
+      // @ts-expect-error
+      const userPasswdInput = inputEl.value;
+      if (!userPasswdInput) {
+        showFailedAnimation(inputEl);
+        acpDialogTitleEl.textContent = "密码不能为空";
+      }
+
+      const crypto = require("crypto");
+      const encPasswd = crypto
+        .createHash("sha512")
+        .update(userPasswdInput + "EndlessX")
+        .digest("hex")
+        .toUpperCase();
+
+      if (encPasswd === password) {
+        await global.__HUGO_AURA_UI_FUNCTIONS__.config.hideAndResetAuthDialog();
+
+        global.__HUGO_AURA_CONFIG__.auraSettings.settingsPasswordWithSalt =
+          password;
+        if (global.__HUGO_AURA_CONFIG__.auraSettings.encryptConfig) {
+          functions.handleEnableConfigEncryption("update", password);
+        }
+        if (resolveFn) resolveFn(true);
+        return;
+      } else {
+        showFailedAnimation(inputEl);
+        acpDialogTitleEl.textContent = "请再试一次";
+        return;
+      }
+    };
+
+    // @ts-expect-error
+    acpDialogConfirmBtnEl.onclick = verifyPassword;
+    // @ts-expect-error
+    acpDialogCancelBtnEl.onclick = (_evt) => {
+      if (resolveFn) resolveFn(false);
+      global.__HUGO_AURA_UI_FUNCTIONS__.config.handleNavBack();
+    };
+
+    return await handleExit();
+  },
+};
+
 const auraSettings = [
   {
     id: 0,
@@ -12,7 +171,7 @@ const auraSettings = [
         restart: false,
         reload: false,
         tip: true,
-        tipTitle: "在 0.1.1-beta 版本发布后, 启用访问密码将加密配置文件",
+        tipTitle: "启用访问密码将自动加密配置文件",
         associateVal: null,
         auraIf: () => true,
         defaultValue: false,
@@ -20,15 +179,62 @@ const auraSettings = [
           return global.__HUGO_AURA_CONFIG__.auraSettings
             .settingsPasswordEnabled;
         },
-        callbackFn: (newVal) => {
+        callbackFn: async (newVal) => {
           if (typeof newVal !== "boolean") return;
           global.__HUGO_AURA_CONFIG__.auraSettings.settingsPasswordEnabled =
             newVal;
-          // TODO: Trigger enc config
+          if (
+            newVal &&
+            global.__HUGO_AURA_CONFIG__.auraSettings.encryptConfig
+          ) {
+            functions.handleEnableConfigEncryption("enc", null);
+          } else if (
+            !newVal &&
+            global.__HUGO_AURA_CONFIG__.auraSettings.encryptConfig
+          ) {
+            await global.__HUGO_AURA_CONFIG_MGR__.switchToDecConfig(
+              global.__HUGO_AURA_CONFIG__,
+              null
+            );
+          }
         },
       },
       {
         index: 1,
+        id: "enableConfigEncryption",
+        type: "switch",
+        name: "加密配置文件",
+        description: "启用后, 本地配置文件将加密保存",
+        restart: false,
+        reload: false,
+        tip: true,
+        tipTitle: "配置文件将以 AES-256-GCM 加密算法在本地保存",
+        warning: true,
+        warningContent: "这可能导致性能问题",
+        associateVal: ["auraSettings.settingsPasswordEnabled"],
+        auraIf: () => {
+          return global.__HUGO_AURA_CONFIG__.auraSettings
+            .settingsPasswordEnabled;
+        },
+        defaultValue: false,
+        valueGetter: () => {
+          return global.__HUGO_AURA_CONFIG__.auraSettings.encryptConfig;
+        },
+        callbackFn: async (newVal) => {
+          if (typeof newVal !== "boolean") return;
+          global.__HUGO_AURA_CONFIG__.auraSettings.encryptConfig = newVal;
+          if (newVal) {
+            functions.handleEnableConfigEncryption("enc", null);
+          } else {
+            await global.__HUGO_AURA_CONFIG_MGR__.switchToDecConfig(
+              global.__HUGO_AURA_CONFIG__,
+              null
+            );
+          }
+        },
+      },
+      {
+        index: 2,
         id: "auraSettingsPasswd",
         type: "input",
         subType: "password",
@@ -48,7 +254,7 @@ const auraSettings = [
         valueGetter: () => {
           return "";
         },
-        callbackFn: (newVal) => {
+        callbackFn: async (newVal) => {
           if (newVal === "" || !newVal) return { valid: true };
           if (newVal.length < 8)
             return { valid: false, hint: "请输入至少 8 位密码" };
@@ -74,9 +280,8 @@ const auraSettings = [
             .update(newVal + "EndlessX")
             .digest("hex")
             .toUpperCase();
-          global.__HUGO_AURA_CONFIG__.auraSettings.settingsPasswordWithSalt =
-            result;
-          return { valid: true };
+
+          return await functions.handle2ndPasswordPrompt(result);
         },
       },
     ],
@@ -84,31 +289,7 @@ const auraSettings = [
   {
     id: 1,
     categoryName: "外观",
-    child: [
-      {
-        index: 0,
-        id: "enablePasswdDialogBlur",
-        type: "switch",
-        name: "密码验证框毛玻璃效果",
-        description: "启用后, 密码验证时, 背景将具有毛玻璃效果",
-        restart: false,
-        reload: false,
-        warning: true,
-        warningContent: "不建议在较旧 (如 i5 8 代) 机型上开启, 可能导致性能问题",
-        associateVal: null,
-        auraIf: () => true,
-        defaultValue: true,
-        valueGetter: () => {
-          return global.__HUGO_AURA_CONFIG__.auraSettings.appearance
-            .enablePasswdDialogBlur;
-        },
-        callbackFn: (newVal) => {
-          if (typeof newVal !== "boolean") return;
-          global.__HUGO_AURA_CONFIG__.auraSettings.appearance.enablePasswdDialogBlur =
-            newVal;
-        },
-      },
-    ],
+    child: [],
   },
 ];
 

src/aura/ui/pls/routes/basic.js

@@ -11,17 +11,32 @@ const basicRouteHandler = (parsedWsMsg) => {
   const target = parsedWsMsg.type.split(".").slice(-1)[0];
   switch (target) {
     case "pushPlsInfo":
-      global.__HUGO_AURA_GLOBAL__.plsStats.status = parsedWsMsg.data.status;
-      global.__HUGO_AURA_GLOBAL__.plsStats.version = parsedWsMsg.data.version;
+      if (global.__HUGO_AURA__.plsStats) {
+        global.__HUGO_AURA__.plsStats.status = parsedWsMsg.data.status;
+        global.__HUGO_AURA__.plsStats.version = parsedWsMsg.data.version;
+      }
 
       global.ipcRenderer.invoke(
         `${IPC_METHOD_BASE}.updatePlsStats`,
-        global.__HUGO_AURA_GLOBAL__.plsStats
+        global.__HUGO_AURA__.plsStats
       );
 
       console.debug(
         "[HugoAura / UI / PLS Routes / DEBUG] Updated plsStats basic info:",
-        global.__HUGO_AURA_GLOBAL__.plsStats
+        global.__HUGO_AURA__.plsStats
+      );
+      break;
+
+    case "plsNotReadyError":
+      if (global.__HUGO_AURA__.plsStats) {
+        global.__HUGO_AURA__.plsStats.launched = true;
+        global.__HUGO_AURA__.plsStats.connected = false;
+        global.__HUGO_AURA__.plsStats.status = "notReady";
+      }
+
+      global.ipcRenderer.invoke(
+        `${IPC_METHOD_BASE}.updatePlsStats`,
+        global.__HUGO_AURA__.plsStats
       );
       break;
     default:

src/aura/utils/crypto.js

@@ -0,0 +1,14 @@
+/**
+ *
+ * @returns {string}
+ */
+const genRandomHex = () => {
+  let result = "";
+  for (let i = 0; i < 8; i++) {
+    const randomNum = Math.floor(Math.random() * 0x10000);
+    result += randomNum.toString(16).padStart(4, "0");
+  }
+  return result;
+};
+
+module.exports = { genRandomHex };

src/aura/utils/eventBus.js

@@ -0,0 +1,47 @@
+class EventBus {
+  constructor() {
+    this.listeners = new Map();
+  }
+
+  on(eventName, callback) {
+    if (!this.listeners.has(eventName)) {
+      this.listeners.set(eventName, new Set());
+    }
+    this.listeners.get(eventName).add(callback);
+    return () => this.off(eventName, callback);
+  }
+
+  off(eventName, callback) {
+    if (this.listeners.has(eventName)) {
+      this.listeners.get(eventName).delete(callback);
+      if (this.listeners.get(eventName).size === 0) {
+        this.listeners.delete(eventName);
+      }
+    }
+  }
+
+  emit(eventName, ...args) {
+    if (this.listeners.has(eventName)) {
+      this.listeners.get(eventName).forEach((callback) => {
+        try {
+          callback(...args);
+        } catch (error) {
+          console.error(
+            `[HugoAura / EventBus] Error in ${eventName} callback:`,
+            error
+          );
+        }
+      });
+    }
+  }
+
+  once(eventName, callback) {
+    const onceCallback = (...args) => {
+      callback(...args);
+      this.off(eventName, onceCallback);
+    };
+    return this.on(eventName, onceCallback);
+  }
+}
+
+module.exports = EventBus;

src/core/hook.js

@@ -1,99 +1,49 @@
 // @ts-check
 
 if (!global.__HUGO_AURA__) {
-  /**
-   * @type {import("../aura/types/main/core").MainProcessGlobal}
-   */
   const __HUGO_AURA__ = {
     hookedWindows: new Map(),
-    hooks: new Map(),
     configInit: false,
+    central: () => {},
+    ipcInit: false,
     plsStats: null,
     plsSettings: null,
     plsRules: null,
+    uiHooks: new Map(),
+    windowHooks: new Map(),
+    version: require("./preload").__AURA_VERSION__,
   };
   global.__HUGO_AURA__ = __HUGO_AURA__;
 }
 
+if (!global.__HUGO_AURA_API__) {
+  /** @type {import("../aura/types/shared/global").GlobalHugoAuraApiInfo} */
+  const __HUGO_AURA_API__ = {
+    domains: [
+      "https://api-aura-projekts.delta.ooo",
+      "https://api-aura.asaka.site",
+      "https://api.hugoaura.dpdns.org",
+      "https://api-aura-projekts.minorice.moe",
+      "https://api.aura.vim.moe"
+    ],
+    plsUpdate: "/api/getPLSLatestVersion",
+    auraUpdate: "/api/getAuraLatestVersion",
+  };
+  global.__HUGO_AURA_API__ = __HUGO_AURA_API__;
+}
+
 if (!global.__HUGO_AURA_CONFIG__) {
   global.__HUGO_AURA_CONFIG__ = {};
 }
 
-const fs = require("fs");
-const util = require("util");
-const path = require("path");
-const os = require("os");
-
 const MainProcessHooksManager = require("../aura/init/main/windowHooksManager");
 const RendererHooksManager = require("../aura/init/rendererHook/uiHooksManager");
+const EventBus = require("../aura/utils/eventBus");
 const NetworkHook = require("../aura/init/rendererHook/networkHook");
-const configManager = require("../aura/init/shared/configManager");
+const ConfigManager = require("../aura/init/shared/configManager");
 const { buildIpcMain } = require("../aura/init/main/ipcHandler");
 
-/**
- *
- * @param {import("../aura/types/main/core").WindowName} windowName
- */
-const initLogger = (windowName) => {
-  const logDir = path.join(os.homedir(), "Documents", "HugoAura", "logs");
-  if (!fs.existsSync(logDir)) {
-    fs.mkdirSync(logDir, { recursive: true });
-  }
-
-  const logFile = path.join(
-    logDir,
-    `main-${windowName}-${new Date().toISOString().replace(/:/g, "-")}.log`
-  );
-  const logStream = fs.createWriteStream(logFile, { flags: "a" });
-
-  const originalConsole = {
-    log: console.log,
-    error: console.error,
-    warn: console.warn,
-    info: console.info,
-    debug: console.debug,
-  };
-
-  console.log = function (...args) {
-    const msg = util.format("[LOG] ", ...args) + "\n";
-    logStream.write(msg);
-    originalConsole.log.apply(console, args);
-  };
-
-  console.error = function (...args) {
-    const msg = util.format("[ERROR] ", ...args) + "\n";
-    logStream.write(msg);
-    originalConsole.error.apply(console, args);
-  };
-
-  console.warn = function (...args) {
-    const msg = util.format("[WARN] ", ...args) + "\n";
-    logStream.write(msg);
-    originalConsole.warn.apply(console, args);
-  };
-
-  console.info = function (...args) {
-    const msg = util.format("[INFO] ", ...args) + "\n";
-    logStream.write(msg);
-    originalConsole.info.apply(console, args);
-  };
-
-  console.debug = function (...args) {
-    if (!process.argv.includes("--aura-debug")) return;
-    const msg = util.format("[DEBUG] ", ...args) + "\n";
-    logStream.write(msg);
-    originalConsole.debug.apply(console, args);
-  };
-
-  process.on("uncaughtException", (err) => {
-    console.error("UNCAUGHT EXCEPTION:", err);
-  });
-
-  console.log(
-    "[HugoAura / Init / Logger] Logger initialized. Log file:",
-    logFile
-  );
-};
+const { initLogger } = require("../aura/init/main/logger");
 
 /**
  *
@@ -101,9 +51,11 @@ const initLogger = (windowName) => {
  * @returns
  */
 const launcher = ({ central, windowName, config }) => {
+  // >>> Init STD <<< //
   process.stdout.isTTY = true;
   process.stderr.isTTY = true;
 
+  // >>> Basic Config <<< //
   /** @type {Electron} */
   const electron = central(1);
   const app = electron.app;
@@ -114,34 +66,59 @@ const launcher = ({ central, windowName, config }) => {
     app.exit(0);
   };
 
+  // >>> Init Logger <<< //
   initLogger(windowName);
 
   console.log("[HugoAura / Loaded] Aura is loaded!");
   console.debug(`[HugoAura / Debug] curWindowName: ${windowName}`);
 
+  // >>> Init EventBus <<< //
+  if (!global.__HUGO_AURA_EVENT_BUS__)
+    global.__HUGO_AURA_EVENT_BUS__ = new EventBus();
+
+  // >>> Init Config <<< //
+  const configManager = new ConfigManager();
+  configManager.side = "main";
   configManager.ensureConfigExists();
   const loadedConfig = configManager.loadConfig();
   if (!global.__HUGO_AURA__.configInit) global.__HUGO_AURA__.configInit = true;
+  if (!global.__HUGO_AURA_CONFIG_MGR__)
+    global.__HUGO_AURA_CONFIG_MGR__ = configManager;
 
   global.__HUGO_AURA_CONFIG__ = loadedConfig;
 
+  global.__HUGO_AURA_EVENT_BUS__.on("$aura.config.refreshConfig", () => {
+    global.__HUGO_AURA_CONFIG__ = configManager.loadConfig();
+  });
+
+  // >>> Init IPC Main <<< //
   if (!global.__HUGO_AURA__.ipcInit) {
     buildIpcMain(electron);
     global.__HUGO_AURA__.ipcInit = true;
   }
 
+  // >>> Init Main Process Hooks <<< //
   const mainProcessHooksManager = new MainProcessHooksManager();
 
   const _windowHooks = mainProcessHooksManager.loadHooks();
 
+  // >>> Init Renderer Process Hooks <<< //
   const uiHooksManager = new RendererHooksManager();
 
   const uiHooks = uiHooksManager.loadHooks();
 
+  // >>> Activate DevTools <<< //
   if (loadedConfig.devTools && !config.canOpenDevTool) {
     config.canOpenDevTool = true;
   }
 
+  // >>> Listeners <<< //
+
+  /**
+   *
+   * @param {any} _event
+   * @param {import("electron").BrowserWindow} browserWindow
+   */
   const browserWindowCreatedListener = (_event, browserWindow) => {
     mainProcessHooksManager.initHookForWindow(
       windowName,
@@ -153,7 +130,7 @@ const launcher = ({ central, windowName, config }) => {
 
   /**
    *
-   * @param {Event} _event
+   * @param {any} _event
    * @param {import("electron").WebContents} webContents
    */
   const webContentsCreatedListener = (_event, webContents) => {
@@ -180,13 +157,10 @@ const launcher = ({ central, windowName, config }) => {
   };
 
   app.once("browser-window-created", browserWindowCreatedListener);
-  // @ts-expect-error
-  // ↑ idk why
   app.once("web-contents-created", webContentsCreatedListener);
 
   return () => {
     app.removeListener("browser-window-created", browserWindowCreatedListener);
-    // @ts-expect-error
     app.removeListener("web-contents-created", webContentsCreatedListener);
   };
 };

src/core/preload.js

@@ -1,9 +1,15 @@
-const __AURA_VERSION__ = "0.1.1-pre-II";
+// @ts-check
+
+const __AURA_VERSION__ = "0.1.1-pre-IV";
 
 (() => {
+  if (require.main) return; // 如果只是导入 Aura Version, 不运行闭包逻辑
+
+  // >>> Init Global Vars <<< //
   if (!global.__HUGO_AURA__) {
     global.__HUGO_AURA__ = {
       configInit: true, // preload 始终比 hook 晚, 默认 config 已初始化
+      // ↑ 保留此参数的目的 -> 用于 configManager 中, configManager 的行为在 Renderer 和 Main 中是一致的
       version: __AURA_VERSION__,
     };
   }
@@ -16,11 +22,29 @@ const __AURA_VERSION__ = "0.1.1-pre-II";
     global.__HUGO_AURA_UI_REACTIVES__ = {};
   }
 
-  const configManager = require("../aura/init/shared/configManager");
+  // >>> Init EventBus <<< //
+  const EventBus = require("../aura/utils/eventBus");
+  if (!global.__HUGO_AURA_EVENT_BUS__) {
+    global.__HUGO_AURA_EVENT_BUS__ = new EventBus();
+  }
+
+  // >>> Load Modules <<< //
+  const ConfigManager = require("../aura/init/shared/configManager");
   const WebpackHook = require("../aura/init/preload/webpackHook");
 
-  console.log(`[HugoAura / AppHook / Preload] Preparing...`);
+  const configManager = new ConfigManager();
+  configManager.side = "renderer";
+  if (!global.__HUGO_AURA_CONFIG_MGR__)
+    global.__HUGO_AURA_CONFIG_MGR__ = configManager;
 
+  console.log(`[HugoAura / Preload] Preparing...`);
+
+  /**
+   *
+   * @param {any} baseObj
+   * @param {(string | symbol)[]} path
+   * @returns
+   */
   const createConfigProxy = (baseObj, path = []) => {
     return new Proxy(baseObj, {
       get(target, prop) {
@@ -37,24 +61,85 @@ const __AURA_VERSION__ = "0.1.1-pre-II";
             value,
           },
         });
+        const pathName = [...path, prop].join(".");
         document.dispatchEvent(configUpdateEvent);
+
+        const settingsEntries = document.getElementsByClassName(
+          "aura-settings-entry"
+        );
+        if (settingsEntries.length > 0) {
+          Array.from(settingsEntries).forEach((entry) => {
+            entry.dispatchEvent(configUpdateEvent);
+          });
+        }
         console.log(
           `[HugoAura / Config] Config changed at path: ${[...path, prop].join(
             "."
           )}, new value: ${value}`
         );
-        configManager.writeConfig(window.__HUGO_AURA_CONFIG__);
+
+        const isEditingEncSettings = pathName.includes(
+          "auraSettings.settingsPassword"
+        );
+
+        if (
+          isEditingEncSettings &&
+          global.__HUGO_AURA_CONFIG__.auraSettings.encryptConfig
+        ) {
+          return true;
+        }
+
+        if (!configManager.useEncConfig) {
+          configManager.writeConfig(window.__HUGO_AURA_CONFIG__); // 仅非加密 Config 使用即时写入, 否则会导致性能问题
+        } else {
+          if (global.__HUGO_AURA_UI_REACTIVES__.config) {
+            global.__HUGO_AURA_UI_REACTIVES__.config.isConfigPendingWrite = true;
+          }
+          if (global.__HUGO_AURA_UI_FUNCTIONS__.config?.handleACSNShow) {
+            global.__HUGO_AURA_UI_FUNCTIONS__.config.handleACSNShow();
+          }
+        }
         return true;
       },
     });
   };
 
-  const initialConfig = configManager.readConfig();
+  const getConfig = () => {
+    /*
+    if (configManager.useEncConfig) {
+      if (!ipcRenderer) ipcRenderer = require("electron").ipcRenderer;
+      const result = ipcRenderer.sendSync("$aura.config.getConfigFromMainSync");
+      if (result.success) {
+        configManager.isConfigReadFailed = false;
+        return result.data;
+      } else {
+        configManager.isConfigReadFailed = true;
+        return configManager.getDefaultConfig();
+      }
+    } else {
+      const result = configManager.readConfig();
+      configManager.isConfigReadFailed = false;
+      return result;
+    }
+    */
+    // ↑ IPC Renderer 在 Preload 时无法访问, 因此无法从主进程拉取配置
+    const result = configManager.readConfig();
+    configManager.isConfigReadFailed = false;
+    return result;
+  };
+
+  // >>> Init Config <<< //
+  const initialConfig = getConfig();
   window.__HUGO_AURA_CONFIG__ = createConfigProxy(initialConfig);
 
+  // >>> Init Renderer Hooks <<< //
   window.__HUGO_AURA_HOOK__ = {};
   const webpackHook = new WebpackHook();
   webpackHook.installHook(window, initialConfig);
 
+  // >>> Done <<< //
   console.log(`[HugoAura / AppHook / DONE] Hooks installed`);
+  console.log(`[HugoAura / Preload / DONE] Preload done`);
 })();
+
+module.exports = { __AURA_VERSION__ };