miao-moe/Seewo-HugoAura
1
0
Fork 0
mirror of https://github.com/HugoAura/Seewo-HugoAura.git synced 2026-06-25 18:54:29 +08:00
Code Issues Packages Projects Releases Wiki Activity

[🔄 Chore] Prepare for Aikari (2/2)

Browse Source
This commit is contained in:
Minoricew
2025-11-16 18:35:53 +08:00
committed by Minorice
parent 08290301a3
commit b277a61923
14 changed files with 586 additions and 333 deletions
Download Patch File Download Diff File Expand all files Collapse all files

131
src/aura/ui/pages/configSubPages/behaviourCtrl/settings/basic.js
View File

@@ -4,28 +4,6 @@ const {
updateAikariConfigToRemote,
} = require(`${REQUIRE_BASE}/../../../../composables/aikariConfigManager`);
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,
@@ -33,137 +11,70 @@ const basicSettings = [
child: [
{
index: 0,
id: "plsListenPort",
id: "aikarWsPreferPort",
type: "input",
subType: "number",
name: "PLS WS 默认监听端口",
description: "PLS 的 WebSocket 服务器将默认监听指定的端口",
name: "Aikari WS 默认监听端口",
description: "Aikari WebSocket 服务器默认监听的端口",
reactive: true,
reactiveVal: ["root.settings"],
restart: false,
reload: false,
AikariRequired: true,
aikariRequired: true,
restartAikari: false,
warning: true,
warningContent: "PLS 仍会在默认端口被占用时, 自动随机端口重试",
warningContent: "Aikari 仍会在默认端口被占用时, 自动随机端口重试",
associateVal: null,
auraIf: () => true,
defaultValue: "",
placeHolder: "输入端口号 (10000 ~ 65535)",
valueGetter: () => {
if (!global.__HUGO_AURA__.aikariSettings) return "";
return global.__HUGO_AURA__.aikariSettings.wsPort;
return global.__HUGO_AURA__.aikariSettings.wsPreferPort;
},
callbackFn: (newVal) => {
if (newVal === "" || !newVal)
return { valid: false, hint: "请输入端口号" };
const numberNewVal = Number(newVal);
if (numberNewVal === NaN || !(10000 <= numberNewVal) || !(newVal <= 65535)) {
if (
numberNewVal === NaN ||
!(10000 <= numberNewVal) ||
!(newVal <= 65535)
) {
return { valid: false, hint: "请输入合法的端口号 (10000 ~ 65535)" };
}
global.__HUGO_AURA__.aikariSettings.wsPort = numberNewVal;
updateAikariConfigToRemote("wsPort", numberNewVal);
global.__HUGO_AURA__.aikariSettings.wsPreferPort = numberNewVal;
updateAikariConfigToRemote("wsPreferPort", 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,
AikariRequired: true,
restartAikari: true,
tip: true,
tipTitle:
'路径相对于 "%PROGRAMDATA%\\HugoAura\\Aura-PLS\\", 使用 "/" 作为路径符',
associateVal: null,
auraIf: () => true,
defaultValue: "",
placeHolder: "输入相对路径, 例如: config/vme50/cert.crt",
valueGetter: () => {
if (!global.__HUGO_AURA__.aikariSettings) return "";
return global.__HUGO_AURA__.aikariSettings.certPath;
},
callbackFn: (newVal) => {
const validate = reusableChkFn.checkRelativePath();
if (!validate.valid) {
return validate;
}
global.__HUGO_AURA__.aikariSettings.certPath = newVal;
updateAikariConfigToRemote("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,
AikariRequired: true,
restartAikari: 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__.aikariSettings) return "";
return global.__HUGO_AURA__.aikariSettings.keyPath;
},
callbackFn: (newVal) => {
const validate = reusableChkFn.checkRelativePath();
if (!validate.valid) {
return validate;
}
global.__HUGO_AURA__.aikariSettings.keyPath = newVal;
updateAikariConfigToRemote("keyPath", newVal);
return { valid: true };
},
},
{
index: 3,
id: "plsRegenCertAftRelaunch",
id: "aikariForceRegenWsTlsCert",
type: "switch",
name: "重新生成 TLS 证书",
description: "PLS 将在下次启动时重新生成 TLS 证书",
name: "重新生成 WS TLS 证书",
description: "Aikari 将在下次启动时重新生成用于 WebSocket 的 TLS 证书",
reactive: true,
reactiveVal: ["root.settings"],
restart: false,
reload: false,
AikariRequired: true,
aikariRequired: true,
restartAikari: true,
associateVal: null,
auraIf: () => true,
defaultValue: false,
valueGetter: () => {
if (!global.__HUGO_AURA__.aikariSettings) return "";
return global.__HUGO_AURA__.aikariSettings.regenCert;
return global.__HUGO_AURA__.aikariSettings.tls.regenWsCertNextLaunch;
},
callbackFn: (newVal) => {
if (typeof newVal !== "boolean") return false;
global.__HUGO_AURA__.aikariSettings.regenCert = newVal;
updateAikariConfigToRemote("regenCert", newVal);
global.__HUGO_AURA__.aikariSettings.tls.regenWsCertNextLaunch =
newVal;
updateAikariConfigToRemote("tls.regenWsCertNextLaunch", newVal);
return true;
},
},

257
src/aura/ui/pages/configSubPages/behaviourCtrl/settings/deviceInfoPost.js Normal file
View File

@@ -0,0 +1,257 @@
// [!] Will be deprecated
const REQUIRE_BASE = ".";
const {
updateAikariPLSRulesToRemote,
} = require(`${REQUIRE_BASE}/../../../../composables/aikariConfigManager`);
const composables = {};
const deviceInfoPostSettings = [
{
id: 0,
categoryName: "冰点管理",
child: [
{
index: 0,
id: "enableFreezeInfoReportOverride",
type: "switch",
name: "启用冰冻状态篡改",
description: "篡改上报的冰冻数据, 可自定义集控端显示的状态",
reactive: true,
reactiveVal: ["root.ruleSettings"],
restart: false,
reload: false,
aikariRequired: true,
restartAikari: false,
associateVal: null,
auraIf: () => true,
defaultValue: false,
valueGetter: () => {
if (!global.__HUGO_AURA__.aikariRules) return "";
return global.__HUGO_AURA__.aikariRules.ssaFeatures.securityPolicies
.freezeManagement.freezeDiskInfoPost.enabled;
},
callbackFn: (newVal) => {
if (typeof newVal !== "boolean") return;
if (!global.__HUGO_AURA__.aikariRules) return;
global.__HUGO_AURA__.aikariRules.ssaFeatures.securityPolicies.freezeManagement.freezeDiskInfoPost.enabled =
newVal;
updateAikariPLSRulesToRemote(
"ssaFeatures.securityPolicies.freezeManagement.freezeDiskInfoPost.enabled",
newVal,
"ssaFeatures.securityPolicies.freezeManagement.freezeDiskInfoPost"
);
return true;
},
},
{
index: 1,
id: "freezeInfoReportFrozenDisks",
type: "checkbox",
name: "被冻结的磁盘",
description: "选中的磁盘会<b>被上报</b>为冻结 (不是实际行为)",
restart: false,
reload: false,
aikariRequired: true,
restartAikari: false,
warning: true,
warningContent:
"如果可选的磁盘盘符与下方预览不一致, 则多出的盘符可能为 DVD 驱动器 / 软盘 / 可移动磁盘, 忽略即可",
reactive: true,
reactiveVal: ["root.ruleSettings"],
associateVal: [
"ssaFeatures.securityPolicies.freezeManagement.freezeDiskInfoPost.enabled",
],
auraIf: () => true,
auraDisable: () => {
if (!global.__HUGO_AURA__.aikariRules) return { value: true };
if (
!global.__HUGO_AURA_UI_REACTIVES__.subConfig.behaviourCtrlShared
.diskCaptions
)
return {
value: true,
tooltip: "发生错误, 请上报至 HugoAura GitHub Issues",
};
if (
!global.__HUGO_AURA_UI_REACTIVES__.subConfig.behaviourCtrlShared
.diskCaptions.length === 0
)
return {
value: true,
tooltip: "发生错误, 请上报至 HugoAura GitHub Issues",
};
return {
value:
!global.__HUGO_AURA__.aikariRules.ssaFeatures.securityPolicies
.freezeManagement.freezeDiskInfoPost.enabled,
};
},
defaultValue: [],
templates: () => {
try {
if (
global.__HUGO_AURA_UI_REACTIVES__.subConfig.behaviourCtrlShared
.diskCaptions.length === 0
) {
return ["error"];
} else {
return global.__HUGO_AURA_UI_REACTIVES__.subConfig.behaviourCtrlShared.diskCaptions.map(
(element) => {
return element.toLowerCase().replace(/:/g, "");
}
);
}
} catch (err) {
console.error(err);
return ["error"];
}
},
templateLabels: () => {
try {
if (
global.__HUGO_AURA_UI_REACTIVES__.subConfig.behaviourCtrlShared
.diskCaptions.length === 0
) {
return ["获取盘符时发生错误, 请上报至 GitHub Issues"];
} else {
return global.__HUGO_AURA_UI_REACTIVES__.subConfig.behaviourCtrlShared.diskCaptions.map(
(element) => {
return element.replace(/:/g, " 盘");
}
);
}
} catch (err) {
console.error(err);
return ["发生未知错误"];
}
},
valueGetter: () => {
if (!global.__HUGO_AURA__.aikariRules) return [];
return global.__HUGO_AURA__.aikariRules.ssaFeatures.securityPolicies
.freezeManagement.freezeDiskInfoPost.frozenDisks;
},
callbackFn: (affectedData, affectedEl) => {
const targetArr =
global.__HUGO_AURA__.aikariRules.ssaFeatures.securityPolicies
.freezeManagement.freezeDiskInfoPost.frozenDisks;
if (affectedEl.checked) {
targetArr.push(affectedData);
} else {
targetArr.splice(targetArr.indexOf(affectedData), 1);
}
updateAikariPLSRulesToRemote(
"ssaFeatures.securityPolicies.freezeManagement.freezeDiskInfoPost.frozenDisks",
targetArr,
"ssaFeatures.securityPolicies.freezeManagement.freezeDiskInfoPost"
);
return true;
},
},
{
index: 2,
id: "freezeInfoReportOverridePreview",
type: "preview",
loaderTarget:
"Aura.UI.Assistant.Config.BehaviourCtrl.DeviceSecurity.FreezeOverridePreview",
associateVal: [
"ssaFeatures.securityPolicies.freezeManagement.freezeDiskInfoPost.frozenDisks",
],
listenerType: "aikari",
},
],
},
{
id: 1,
categoryName: "软件信息",
child: [
{
index: 0,
id: "enableSoftwareReportPostOverride",
type: "switch",
name: "启用软件信息上报覆写",
description:
'覆写上报的软件信息, 可自定义集控端 "设备管控" - <设备名> - "软件列表" 下的信息显示',
reactive: true,
reactiveVal: ["root.ruleSettings"],
restart: false,
reload: false,
aikariRequired: true,
restartAikari: false,
warning: true,
warningContent: '此功能与 "弹窗拦截" 等无关',
associateVal: null,
auraIf: () => true,
defaultValue: false,
valueGetter: () => {
if (!global.__HUGO_AURA__.aikariRules) return false;
return global.__HUGO_AURA__.aikariRules.deviceInfo.software
.softwareReportPost.enabled;
},
callbackFn: (newVal) => {
if (typeof newVal !== "boolean") return;
if (!global.__HUGO_AURA__.aikariRules) return;
global.__HUGO_AURA__.aikariRules.deviceInfo.software.softwareReportPost.enabled =
newVal;
updateAikariPLSRulesToRemote(
"deviceInfo.software.softwareReportPost.enabled",
newVal,
"deviceInfo.software.softwareReportPost"
);
return true;
},
},
{
index: 1,
id: "enableSoftwareReportPostSetAsEmpty",
type: "switch",
name: "清空软件上报列表",
description: "将上报列表置空, 集控端将无法看到任何已安装应用",
reactive: true,
reactiveVal: ["root.ruleSettings"],
restart: false,
reload: false,
aikariRequired: true,
restartAikari: false,
associateVal: ["deviceInfo.software.softwareReportPost.enabled"],
auraIf: () => true,
auraDisable: () => {
if (!global.__HUGO_AURA__.aikariRules) return { value: true };
return {
value:
!global.__HUGO_AURA__.aikariRules.deviceInfo.software
.softwareReportPost.enabled,
};
},
defaultValue: true,
valueGetter: () => {
if (!global.__HUGO_AURA__.aikariRules) return true;
return global.__HUGO_AURA__.aikariRules.deviceInfo.software
.softwareReportPost.setAsEmpty;
},
callbackFn: (newVal) => {
if (typeof newVal !== "boolean") return;
if (!global.__HUGO_AURA__.aikariRules) return;
global.__HUGO_AURA__.aikariRules.deviceInfo.software.softwareReportPost.setAsEmpty =
newVal;
updateAikariPLSRulesToRemote(
"deviceInfo.software.softwareReportPost.setAsEmpty",
newVal,
"deviceInfo.software.softwareReportPost"
);
return true;
},
},
],
},
];
module.exports = { deviceInfoPostSettings };

99
src/aura/ui/pages/configSubPages/behaviourCtrl/settings/deviceSecurity.js
View File

@@ -1,99 +0,0 @@
const REQUIRE_BASE = ".";
const {
updateAikariConfigToRemote,
} = require(`${REQUIRE_BASE}/../../../../composables/aikariConfigManager`);
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,
AikariRequired: true,
restartAikari: false,
associateVal: null,
auraIf: () => true,
defaultValue: false,
valueGetter: () => {
if (!global.__HUGO_AURA__.aikariRules) return "";
return global.__HUGO_AURA__.aikariRules.client.security.uploadFreezeInfo
.enable;
},
callbackFn: (newVal) => {
if (typeof newVal !== "boolean") return;
if (!global.__HUGO_AURA__.aikariRules) return;
global.__HUGO_AURA__.aikariRules.client.security.uploadFreezeInfo.enable =
newVal;
updateAikariConfigToRemote(
"ruleSettings.client.security.uploadFreezeInfo.enable",
newVal
);
return true;
},
},
{
index: 1,
id: "freezeInfoReportOverrideType",
type: "radio",
name: "篡改模式",
description:
"选择一种篡改模式, 选中的磁盘范围会<b>被上报</b>为冻结 (不是实际行为)",
restart: false,
reload: false,
AikariRequired: true,
restartAikari: false,
reactive: true,
reactiveVal: ["root.ruleSettings"],
associateVal: ["ruleSettings.client.security.uploadFreezeInfo.enable"],
auraIf: () => {
if (!global.__HUGO_AURA__.aikariRules) return true;
return global.__HUGO_AURA__.aikariRules.client.security.uploadFreezeInfo
.enable;
},
defaultValue: "allFreeze",
templates: ["allFreeze", "systemOnly", "exceptSecondDisk"],
templateLabels: ["全部冻结", "仅系统盘", "第二磁盘除外"],
valueGetter: () => {
if (!global.__HUGO_AURA__.aikariRules) return;
return global.__HUGO_AURA__.aikariRules.client.security.uploadFreezeInfo
.rewriteMode;
},
callbackFn: (newVal) => {
global.__HUGO_AURA__.aikariRules.client.security.uploadFreezeInfo.rewriteMode =
newVal;
updateAikariConfigToRemote(
"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 };

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

@@ -36,8 +36,8 @@
resolve({
success: true,
data: null,
status: response.status
})
status: response.status,
});
}
const parsedData = await response.json();
@@ -84,7 +84,7 @@
const diskElTemplate = document.createElement("p");
diskElTemplate.classList.add("acs-bc-dsc-fop-disk-el");
if (!curConfig.enable) {
if (!curConfig.enabled) {
for (const disk of curDisks) {
const curDiskEl = diskElTemplate.cloneNode();
if (disk.status !== 0) {
@@ -95,44 +95,16 @@
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;
let idx = 0;
for (const disk of curDisks) {
const curDiskEl = diskElTemplate.cloneNode();
if (curConfig.frozenDisks.includes(disk.name.toLowerCase())) {
// @ts-expect-error
curDiskEl.classList.add("active");
}
curDiskEl.textContent = `${disk.name.toUpperCase()} 盘`;
diskContainerEl.appendChild(curDiskEl);
idx += 1;
}
}
@@ -148,10 +120,10 @@
)[0];
const eventListener = (_event) => {
// if (!global.__HUGO_AURA__.plsRules) return;
if (!global.__HUGO_AURA__.aikariRules) return;
composables.getAndUpdateDiskInfo(
// global.__HUGO_AURA__.plsRules.client.security.uploadFreezeInfo
{ enable: false }
global.__HUGO_AURA__.aikariRules.ssaFeatures.securityPolicies
.freezeManagement.freezeDiskInfoPost
);
};
rootEl.addEventListener("onAssociateValueUpdated", eventListener);