[Feat] Further PLS ctrl & childProc perf improvements

2026-06-21 23:54:26 +08:00 · 2025-06-07 23:51:54 +08:00
parent 50bde49414
commit 8ab55bc93c
19 changed files with 1531 additions and 373 deletions
--- a/src/aura/init/shared/registryManager.js
+++ b/src/aura/init/shared/registryManager.js
@@ -1,20 +1,52 @@
 // @ts-check

-const childProc = require("child_process");
+const { exec, execSync } = require("child_process");

 // Constants

 const LOG_PREFIX = "[HugoAura / Init / Reg";
 const LOG_PREFIX_FUNC = "[HugoAura / Reg";
-const AURA_REGISTRY_PATH = ["HKCU", "SOFTWARE", "HugoAura"].join("\\");
+const AURA_REGISTRY_PATH = ["HKEY_USERS", ".DEFAULT", "SOFTWARE", "HugoAura"].join("\\");

 class RegistryManager {
  /**
   * @param {string} [path]
+   * @returns {Promise<boolean>}
   */
-  handleCreateReg(path) {
+  async handleCreateReg(path) {
    try {
-      const createResult = childProc.execSync(["reg", "add", path].join(" "), {
+      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",
      });

@@ -27,6 +59,8 @@ class RegistryManager {
          createResult
        );
        return true;
+      } else {
+        return false;
      }
    } catch (e) {
      console.error(
@@ -37,9 +71,37 @@ class RegistryManager {
    }
  }

-  initRegistry() {
+  /**
+   * @returns {Promise<boolean>}
+   */
+  async initRegistry() {
    try {
-      const queryResult = childProc.execSync(
+      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" }
      );
@@ -48,23 +110,81 @@ class RegistryManager {
        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.handleCreateReg(AURA_REGISTRY_PATH);
+      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 }>}
   */
-  createOrUpdateRegKey(relativePath, keyName, keyVal, silent = false) {
+  async createOrUpdateRegKey(relativePath, keyName, keyVal, silent = false) {
    try {
-      const result = childProc.execSync(
+      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",
@@ -83,21 +203,76 @@ class RegistryManager {
      if (result) {
        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:`,
+            `${LOG_PREFIX} / SUCCESS] Successfully created / updated reg key ${relativePath}/${keyName} with data: ${keyVal}`,
            result
          );
+          console.error("");
        }
-        return {
-          success: true,
-          error: null,
-        };
      }
+      return {
+        success: true,
+        error: null,
+      };
    } catch (e) {
      console.error(
-        `${LOG_PREFIX_FUNC} / ERROR] Failed to create / update reg key, 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 {
@@ -107,24 +282,21 @@ class RegistryManager {
    }
  }

-  /*>>> BUC <<<
-  keyName === null --> delete the whole entry
-  >>> EUC <<<*/
  /**
-   *
   * @param {string} relativePath
   * @param {string | null} keyName
   * @param {boolean | undefined} silent
+   * @returns {{ success: boolean, error: Error | null }}
   */
-  delRegKey(relativePath, keyName, silent = false) {
+  delRegKeySync(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 string accepted.`
+        `${LOG_PREFIX_FUNC} / CRITICAL] Arg \"keyName\" for function \"delRegKeySync\" cannot be undefined. Only null or string accepted.`
      );
    }

    try {
-      const result = childProc.execSync(
+      const result = execSync(
        [
          "reg",
          "delete",
@@ -150,6 +322,11 @@ class RegistryManager {
          success: true,
          error: null,
        };
+      } else {
+        return {
+          success: false,
+          error: null,
+        };
      }
    } catch (e) {
      console.error(
@@ -164,14 +341,76 @@ class RegistryManager {
  }

  /**
-   *
   * @param {string} relativePath
   * @param {string} keyName
   * @param {boolean | undefined} silent
+   * @returns {Promise<{ success: boolean, data: string | null, error: Error | null }>}
   */
-  readRegKey(relativePath, keyName, silent = false) {
+  async readRegKey(relativePath, keyName, silent = false) {
    try {
-      const readResult = childProc.execSync(
+      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",
@@ -185,14 +424,14 @@ class RegistryManager {
      if (readResult) {
        if (!silent) {
          console.debug(
-            `${LOG_PREFIX}] Successfully read reg key ${relativePath}/${keyName}, stdout:`,
+            `${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_FUNC} / WARN] Data not found in stdout`);
+          console.warn(`${LOG_PREFIX} / WARN] Data not found in stdout`);
          return {
            success: false,
            data: null,
@@ -206,10 +445,16 @@ class RegistryManager {
          data,
          error: null,
        };
+      } else {
+        return {
+          success: false,
+          data: null,
+          error: null,
+        };
      }
    } catch (e) {
      console.error(
-        `${LOG_PREFIX_FUNC} / ERROR] Failed to read reg key, error:`,
+        `${LOG_PREFIX} / ERROR] Failed to read reg key, error:`,
        silent ? "<Hidden>" : e
      );
      return {