@ahana-awesome-platform/ahana-electron-sdk 1.0.0

package/dist/esm/windows-registry-B92IgP1f.js

@@ -0,0 +1,354 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import { n as normalizeRegistryPathAdvanced } from "./index-Dys2BW-7.js";
+import { exec } from "child_process";
+const execAsync = (command, options = { encoding: "utf8", windowsHide: true }) => new Promise((resolve, reject) => {
+  exec(command, options, (error, stdout, stderr) => {
+    if (error) {
+      reject({
+        message: error.message,
+        stdout,
+        stderr
+      });
+    } else {
+      resolve({ stdout, stderr });
+    }
+  });
+});
+class WindowsRegistryError extends Error {
+  constructor(message, hive, key, valueName) {
+    super(message);
+    __publicField(this, "hive");
+    __publicField(this, "key");
+    __publicField(this, "valueName");
+    this.hive = hive;
+    this.key = key;
+    this.valueName = valueName;
+    this.name = "WindowsRegistryError";
+  }
+}
+const _WindowsRegistry = class _WindowsRegistry {
+  constructor() {
+  }
+  static getInstance() {
+    if (!_WindowsRegistry.instance) {
+      _WindowsRegistry.instance = new _WindowsRegistry();
+    }
+    return _WindowsRegistry.instance;
+  }
+  // 核心方法
+  static buildRegPath(hive, key) {
+    let regPath = `${hive}:${key}`;
+    regPath = normalizeRegistryPathAdvanced(regPath);
+    return regPath;
+  }
+  static convertToRegType(value) {
+    if (typeof value === "string") {
+      return { type: "REG_SZ", data: value };
+    } else if (typeof value === "number") {
+      if (Number.isInteger(value)) {
+        return { type: "REG_DWORD", data: `0x${value.toString(16)}` };
+      } else {
+        return { type: "REG_BINARY", data: Buffer.from(value.toString()).toString("hex") };
+      }
+    } else if (typeof value === "boolean") {
+      return { type: "REG_DWORD", data: value ? "0x1" : "0x0" };
+    } else if (value === null) {
+      return { type: "REG_SZ", data: "" };
+    } else if (Array.isArray(value)) {
+      const data = value.join("\0") + "\0";
+      return { type: "REG_MULTI_SZ", data };
+    } else if (Buffer.isBuffer(value)) {
+      return { type: "REG_BINARY", data: value.toString("hex") };
+    } else {
+      return { type: "REG_SZ", data: JSON.stringify(value) };
+    }
+  }
+  static parseRegValue(output) {
+    var _a;
+    const lines = output.trim().split("\n");
+    for (const line of lines) {
+      if (line.includes("REG_SZ") || line.includes("REG_EXPAND_SZ")) {
+        const match = line.match(/(REG_SZ|REG_EXPAND_SZ)\s+(.+)/);
+        if (match)
+          return match[2].trim();
+      } else if (line.includes("REG_DWORD")) {
+        const match = line.match(/REG_DWORD\s+(0x[0-9a-fA-F]+)/);
+        if (match)
+          return parseInt(match[1], 16);
+      } else if (line.includes("REG_QWORD")) {
+        const match = line.match(/REG_QWORD\s+(0x[0-9a-fA-F]+)/);
+        if (match)
+          return parseInt(match[1], 16);
+      } else if (line.includes("REG_MULTI_SZ")) {
+        const match = line.match(/REG_MULTI_SZ\s+(.+)/);
+        if (match) {
+          const data = match[1].trim();
+          return data.split("\0").filter((str) => str !== "");
+        }
+      } else if (line.includes("REG_BINARY")) {
+        const match = line.match(/REG_BINARY\s+([0-9a-fA-F\s]+)/);
+        if (match) {
+          const hexString = match[1].replace(/\s+/g, "");
+          return Buffer.from(hexString, "hex");
+        }
+      }
+    }
+    const lastLine = (_a = lines[lines.length - 1]) == null ? void 0 : _a.trim();
+    return lastLine || null;
+  }
+  static async safeOperation(operation, options = {}, operationName = "操作") {
+    const { retryCount = 3, retryDelay = 100 } = options;
+    for (let attempt = 1; attempt <= retryCount; attempt++) {
+      try {
+        return await operation();
+      } catch (error) {
+        if (attempt < retryCount) {
+          console.warn(`${operationName} 失败，第 ${attempt} 次重试:`, error);
+          await this.delay(retryDelay * attempt);
+        } else if (error instanceof Error) {
+          throw new WindowsRegistryError(`${operationName} 失败: ${error.message}`, void 0, void 0, void 0);
+        }
+      }
+    }
+    throw new WindowsRegistryError(`${operationName} 失败，未知错误`);
+  }
+  static delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  // 基本操作
+  static async getValue(hive, key, valueName, options = {}) {
+    return this.safeOperation(async () => {
+      const regPath = this.buildRegPath(hive, key);
+      try {
+        const { stdout, stderr } = await execAsync(`reg query "${regPath}" /v "${valueName}"`, {
+          encoding: "utf8",
+          windowsHide: true
+        });
+        if (stderr) {
+          throw new Error(stderr);
+        }
+        const value = this.parseRegValue(stdout);
+        return { value, exists: true };
+      } catch (error) {
+        if (error instanceof Error && (error.message.includes("错误: 系统找不到指定的注册表项或值。") || error.message.includes("ERROR: The system was unable to find the specified registry key or value."))) {
+          return { value: null, exists: false };
+        }
+        throw error;
+      }
+    }, options, "读取注册表值");
+  }
+  static async setValue(hive, key, valueName, value, options = {}) {
+    return this.safeOperation(async () => {
+      const regPath = this.buildRegPath(hive, key);
+      const { type, data } = this.convertToRegType(value);
+      if (options.backupBeforeModify) {
+        const backup = await this.getValue(hive, key, valueName);
+        if (backup.exists) {
+          this.valueBackupCache.set(`${hive}:${key}:${valueName}`, backup);
+        }
+      }
+      const command = `reg add "${regPath}" /v "${valueName}" /t ${type} /d "${data}" /f`;
+      const { stderr } = await execAsync(command, {
+        encoding: "utf8",
+        windowsHide: true
+      });
+      if (stderr && !stderr.includes("操作成功完成")) {
+        throw new Error(stderr);
+      }
+    }, options, "设置注册表值");
+  }
+  static async deleteValue(hive, key, valueName, options = {}) {
+    return this.safeOperation(async () => {
+      const regPath = this.buildRegPath(hive, key);
+      if (options.backupBeforeModify) {
+        const backup = await this.getValue(hive, key, valueName);
+        if (backup.exists) {
+          this.valueBackupCache.set(`${hive}:${key}:${valueName}`, backup);
+        }
+      }
+      const command = `reg delete "${regPath}" /v "${valueName}" /f`;
+      const { stderr } = await execAsync(command, {
+        encoding: "utf8",
+        windowsHide: true
+      });
+      if (stderr && !stderr.includes("操作成功完成")) {
+        if (stderr.includes("错误: 系统找不到指定的注册表项或值。") || stderr.includes("ERROR: The system was unable to find the specified registry key or value.")) {
+          return;
+        }
+        throw new Error(stderr);
+      }
+    }, options, "删除注册表值");
+  }
+  static async createKey(hive, key, options = {}) {
+    return this.safeOperation(async () => {
+      const regPath = this.buildRegPath(hive, key);
+      const command = `reg add "${regPath}" /f`;
+      const { stderr } = await execAsync(command, {
+        encoding: "utf8",
+        windowsHide: true
+      });
+      if (stderr && !stderr.includes("操作成功完成")) {
+        throw new Error(stderr);
+      }
+    }, options, "创建注册表键");
+  }
+  static async deleteKey(hive, key, options = {}) {
+    return this.safeOperation(async () => {
+      const regPath = this.buildRegPath(hive, key);
+      const command = `reg delete "${regPath}" /f`;
+      const { stderr } = await execAsync(command, {
+        encoding: "utf8",
+        windowsHide: true
+      });
+      if (stderr && !stderr.includes("操作成功完成")) {
+        if (stderr.includes("错误: 系统找不到指定的注册表项或值。") || stderr.includes("ERROR: The system was unable to find the specified registry key or value.")) {
+          return;
+        }
+        throw new Error(stderr);
+      }
+    }, options, "删除注册表键");
+  }
+  // 高级操作
+  static async listKeys(hive, key, options = {}) {
+    return this.safeOperation(async () => {
+      const regPath = this.buildRegPath(hive, key);
+      try {
+        const { stdout, stderr } = await execAsync(`reg query "${regPath}"`, {
+          encoding: "utf8",
+          windowsHide: true
+        });
+        if (stderr)
+          throw new Error(stderr);
+        return this.parseRegistryKeysSimple(stdout, hive, key);
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (errorMessage.includes("错误: 系统找不到指定的注册表项或值。") || errorMessage.includes("ERROR: The system was unable to find the specified registry key or value.")) {
+          return [];
+        }
+        throw error;
+      }
+    }, options, "枚举子键");
+  }
+  static parseRegistryKeysSimple(stdout, hive, key) {
+    const subKeys = /* @__PURE__ */ new Set();
+    for (const line of stdout.trim().split("\n")) {
+      const match = line.match(/HKEY_[A-Z_]+\\(.+)/);
+      if (!match)
+        continue;
+      const fullPath = match[1];
+      if (!fullPath.startsWith(key) || fullPath === key)
+        continue;
+      const relativePath = fullPath.substring(key.length + 1);
+      const subKey = relativePath.split("\\")[0];
+      if (subKey)
+        subKeys.add(subKey);
+    }
+    return Array.from(subKeys);
+  }
+  static async listValues(hive, key, options = {}) {
+    return this.safeOperation(async () => {
+      const regPath = this.buildRegPath(hive, key);
+      const values = [];
+      try {
+        const { stdout, stderr } = await execAsync(`reg query "${regPath}"`, {
+          encoding: "utf8",
+          windowsHide: true
+        });
+        if (stderr || !stdout) {
+          throw new Error(stderr);
+        }
+        const lines = stdout.trim().split("\n");
+        let isValuesSection = false;
+        for (const line of lines) {
+          if (line.includes("(默认)") || line.includes("(Default)")) {
+            isValuesSection = true;
+          }
+          if (isValuesSection && line.trim() && !line.includes("REG_")) {
+            const match = line.match(/^\s*(.+?)\s+(REG_[A-Z_]+)\s+(.+)$/);
+            if (match) {
+              const [, name, , valueStr] = match;
+              values.push({
+                name: name.trim(),
+                value: valueStr.trim()
+              });
+            }
+          }
+        }
+      } catch (error) {
+        if ((error instanceof Error ? error.message : String(error)).includes("错误: 系统找不到指定的注册表项或值。") || (error instanceof Error ? error.message : String(error)).includes("ERROR: The system was unable to find the specified registry key or value.")) {
+          return [];
+        }
+        throw error;
+      }
+      return values;
+    }, options, "枚举注册表值");
+  }
+  static async getKeyInfo(hive, key, options = {}) {
+    return this.safeOperation(async () => {
+      const [subKeys, values] = await Promise.all([
+        this.listKeys(hive, key, options),
+        this.listValues(hive, key, options)
+      ]);
+      return {
+        name: key,
+        subKeys,
+        values
+      };
+    }, options, "获取注册表键信息");
+  }
+  // 批量操作
+  static async batchSetValues(hive, key, values, options = {}) {
+    return this.safeOperation(async () => {
+      for (const [valueName, { value }] of Object.entries(values)) {
+        await this.setValue(hive, key, valueName, value, options);
+      }
+    }, options, "批量设置注册表值");
+  }
+  // 工具方法
+  static async keyExists(hive, key) {
+    try {
+      const regPath = this.buildRegPath(hive, key);
+      const { stderr } = await execAsync(`reg query "${regPath}"`, {
+        encoding: "utf8",
+        windowsHide: true
+      });
+      return !stderr || stderr.includes("操作成功完成");
+    } catch (error) {
+      return false;
+    }
+  }
+  static async valueExists(hive, key, valueName, options = {}) {
+    try {
+      const result = await this.getValue(hive, key, valueName, options);
+      return result.exists;
+    } catch (error) {
+      return false;
+    }
+  }
+  // 恢复备份
+  static async restoreBackup(hive, key, valueName) {
+    const cacheKey = `${hive}:${key}:${valueName}`;
+    const backup = this.valueBackupCache.get(cacheKey);
+    if (backup) {
+      if (backup.exists) {
+        await this.setValue(hive, key, valueName, backup.value);
+      } else {
+        await this.deleteValue(hive, key, valueName);
+      }
+      this.valueBackupCache.delete(cacheKey);
+      return true;
+    }
+    return false;
+  }
+};
+__publicField(_WindowsRegistry, "instance", null);
+__publicField(_WindowsRegistry, "valueBackupCache", /* @__PURE__ */ new Map());
+let WindowsRegistry = _WindowsRegistry;
+export {
+  WindowsRegistry
+};

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@ahana-awesome-platform/ahana-electron-sdk",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "",
+  "main": "/dist/esm/index.js",
+  "module": "/dist/cjs/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/esm/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js"
+    },
+    "./controller": {
+      "types": "./dist/esm/controller/index.d.ts",
+      "import": "./dist/esm/controller/index.js",
+      "require": "./dist/cjs/controller/index.js"
+    },
+    "./ipc": {
+      "types": "./dist/esm/ipc/index.d.ts",
+      "import": "./dist/esm/ipc/index.js",
+      "require": "./dist/cjs/ipc/index.js"
+    },
+    "./logger": {
+      "types": "./dist/esm/logger/index.d.ts",
+      "import": "./dist/esm/logger/index.js",
+      "require": "./dist/cjs/logger/index.js"
+    },
+    "./orm": {
+      "types": "./dist/esm/orm/index.d.ts",
+      "import": "./dist/esm/orm/index.js",
+      "require": "./dist/cjs/orm/index.js"
+    },
+    "./platform": {
+      "types": "./dist/esm/platform/index.d.ts",
+      "import": "./dist/esm/platform/index.js",
+      "require": "./dist/cjs/platform/index.js"
+    },
+    "./response-factory": {
+      "types": "./dist/esm/response-factory/index.d.ts",
+      "import": "./dist/esm/response-factory/index.js",
+      "require": "./dist/cjs/response-factory/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "package.json"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "vite:build:cjs": "cross-env BUILD_FORMAT=cjs vite build",
+    "vite:build:esm": "cross-env BUILD_FORMAT=esm vite build",
+    "vite:build": "pnpm run vite:build:cjs && pnpm run vite:build:esm"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "packageManager": "pnpm@10.8.1",
+  "dependencies": {
+    "reflect-metadata": "^0.2.2",
+    "sequelize": "^6.37.7",
+    "winston": "^3.19.0",
+    "winston-daily-rotate-file": "^5.0.0"
+  },
+  "devDependencies": {
+    "@rollup/plugin-terser": "0.4.4",
+    "@types/node": "^22.19.3",
+    "@ahana-awesome-platform/shared-types": "workspace:*"
+  }
+}