Skip to content

CodexBar 是一个 macOS 菜单栏应用,用于查看本机 Codex 账号状态、额度、Token 用量、详细统计信息

refactor: 按职责重组电源 Helper 并简化睡眠控制

Bobef459f059eb8
diff --git a/.swiftlint.yml b/.swiftlint.yml
index b462320..b74993d 100644
--- a/.swiftlint.yml
+++ b/.swiftlint.yml
@@ -1,8 +1,7 @@
included:
- CodexBar
- - CodexBarTests
- - CodexBarHelperTests
- - CodexBarHelperManager
+ - Tests
+ - CodexBarHelper
- Shared
line_length:
diff --git a/AGENTS.md b/AGENTS.md
index 984c25f..fe669de 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -54,9 +54,9 @@
## 项目结构与模块组织
-CodexBar 是面向 macOS 的 `LSUIElement` 菜单栏应用,使用 Swift 6, SwiftUI, AppKit 和 MVVM。工程只有 `CodexBar` scheme,包含主 App、`CodexBarHelperManager`、`CodexBarHelper`、`CodexBarTests` 和 `CodexBarHelperTests` 五个 target。
+CodexBar 是面向 macOS 的 `LSUIElement` 菜单栏应用,使用 Swift 6, SwiftUI, AppKit 和 MVVM。工程只有 `CodexBar` scheme,包含主 App、`CodexBarPowerHelperManager`、`CodexBarPowerHelper`、`CodexBarTests` 和 `CodexBarPowerHelperTests` 五个 target。
-`CodexBar/` 按 `App/` `Views/` `Controllers/` `Models/` `Services/` 和 `Resources/` 分层。`CodexBarHelperManager/` 提供嵌入主 App 的 Helper 管理 App,拥有 root LaunchDaemon 的注册与授权归属。root LaunchDaemon 位于 `CodexBarHelper/` 目录,主 App 直接与其通信;跨 target 协议位于 `Shared/` 目录。`Scripts/` 提供发布和 helper 清理工具,`Images/` 存放 README 资源。
+`CodexBar/` 按 `App/` `Views/` `Controllers/` `Models/` `Services/` 和 `Resources/` 分层。`CodexBarHelper/` 按职责组织 Helper;其中 `Power/Daemon/` 提供电源管理的 root LaunchDaemon,主 App 直接与其通信;`Power/Manager/` 提供嵌入主 App 的管理 App,拥有该 daemon 的注册与授权归属;`Power/Shared/` 存放跨 target 协议与身份定义,`Power/Artwork/` 存放图标设计源文件。通用跨 target 工具位于 `Shared/`。测试统一放在 `Tests/`,按被测模块划分为 `App/` 和 `Helpers/`。`Scripts/` 提供发布和 Helper 清理工具,`Images/` 存放 README 资源。
## 构建、测试与开发命令
@@ -143,9 +143,13 @@ CodexBar 是面向 macOS 的 `LSUIElement` 菜单栏应用,使用 Swift 6, Swi
## 测试规范
-`CodexBarTests` 使用 Swift Testing,无 App 宿主,直接编译 `CodexBar/` 与 `Shared/` 源码。测试 target 独有的 `CODEXBAR_TESTING` 条件只移除 `@main`,不启动 App、Codex、CloudKit 或 helper。文件测试使用独立临时目录,偏好测试使用独立 `UserDefaults` suite,禁止读写真实用户数据。`CodexBarHelperTests` 独立编译 helper 与 `Shared/` 源码,排除 `main.swift`,通过模拟睡眠操作和内存存储验证 helper,不启动 root 服务或修改系统状态。仓库没有覆盖率门槛。
+根据改动的影响范围和风险选择验证方式。测试入口、源码归属、编译条件和工具配置以当前工程为准。
-每次代码改动至少应完成构建和单元测试,运行 `swiftformat` 和 `swiftlint` 两项检查,并手动验证受影响流程。菜单、窗口焦点、活动采集、同步、通知和防睡眠改动必须说明手动验证场景。Debug 与 Release 使用不同 App 和 helper bundle ID,排查时不要混用。
+- 测试围绕可观察行为、关键边界和失败恢复设计,优先复用现有测试;新增测试应能发现实际回归,避免只重复实现或为简单改名机械补测
+- 单元测试使用独立临时数据和可控依赖,测试结束后清理资源;不得读写真实用户数据、调用真实外部服务、启动特权服务或修改系统设置
+- 代码改动需完成受影响目标的构建、相关自动化测试及项目配置的格式和静态检查;涉及共享逻辑、构建配置或跨模块行为时,扩大验证范围;纯文档改动检查内容和格式即可
+- 自动化测试无法覆盖的交互、系统集成和生命周期行为,补充手动验证;验证前确认运行产物、构建配置和测试环境,避免混用不同版本
+- 交付时说明实际执行的验证及结果;未执行或受环境限制的项目应明确列出,并说明待验证场景,不以构建通过代替运行行为验证
## Git 规范
diff --git a/CodexBarHelperManager/Resources/AppIcon.icon/Assets/CodexBar Helper.png b/Artwork/CodexBar Power Helper.icon/Assets/CodexBar Power Helper.png
similarity index 100%
rename from CodexBarHelperManager/Resources/AppIcon.icon/Assets/CodexBar Helper.png
rename to Artwork/CodexBar Power Helper.icon/Assets/CodexBar Power Helper.png
diff --git a/CodexBarHelperManager/Resources/AppIcon.icon/icon.json b/Artwork/CodexBar Power Helper.icon/icon.json
similarity index 77%
rename from CodexBarHelperManager/Resources/AppIcon.icon/icon.json
rename to Artwork/CodexBar Power Helper.icon/icon.json
index f1b3634..bf07644 100644
--- a/CodexBarHelperManager/Resources/AppIcon.icon/icon.json
+++ b/Artwork/CodexBar Power Helper.icon/icon.json
@@ -4,8 +4,8 @@
{
"layers" : [
{
- "image-name" : "CodexBar Helper.png",
- "name" : "CodexBar Helper"
+ "image-name" : "CodexBar Power Helper.png",
+ "name" : "CodexBar Power Helper"
}
],
"shadow" : {
diff --git a/Resources/CodexBar Helper.pxd b/Artwork/CodexBar Power Helper.pxd
similarity index 100%
rename from Resources/CodexBar Helper.pxd
rename to Artwork/CodexBar Power Helper.pxd
diff --git a/Resources/CodexBar.icon/Assets/CodexBar.png b/Artwork/CodexBar.icon/Assets/CodexBar.png
similarity index 100%
rename from Resources/CodexBar.icon/Assets/CodexBar.png
rename to Artwork/CodexBar.icon/Assets/CodexBar.png
diff --git a/Resources/CodexBar.icon/icon.json b/Artwork/CodexBar.icon/icon.json
similarity index 100%
rename from Resources/CodexBar.icon/icon.json
rename to Artwork/CodexBar.icon/icon.json
diff --git a/Resources/CodexBar.pxd b/Artwork/CodexBar.pxd
similarity index 100%
rename from Resources/CodexBar.pxd
rename to Artwork/CodexBar.pxd
diff --git a/CodexBar.xcodeproj/project.pbxproj b/CodexBar.xcodeproj/project.pbxproj
index f2cbf50..00686e6 100644
--- a/CodexBar.xcodeproj/project.pbxproj
+++ b/CodexBar.xcodeproj/project.pbxproj
@@ -7,10 +7,10 @@
objects = {
/* Begin PBXBuildFile section */
- B10000000000000000000005 /* CodexBarHelper in Embed CodexBar Helper */ = {isa = PBXBuildFile; fileRef = B10000000000000000000014 /* CodexBarHelper */; settings = {ATTRIBUTES = (CodeSignOnCopy, ); }; };
+ B10000000000000000000005 /* CodexBarPowerHelper in Embed CodexBar Power Helper */ = {isa = PBXBuildFile; fileRef = B10000000000000000000014 /* CodexBarPowerHelper */; settings = {ATTRIBUTES = (CodeSignOnCopy, ); }; };
C42A52F12FDACDEC004A2B53 /* Sparkle in Frameworks */ = {isa = PBXBuildFile; productRef = C42A52F02FDACDEC004A2B53 /* Sparkle */; };
D10000000000000000000001 /* Sparkle in Frameworks */ = {isa = PBXBuildFile; productRef = C42A52F02FDACDEC004A2B53 /* Sparkle */; };
- F10000000000000000000001 /* CodexBar Helper Debug.app in Embed Helper Manager */ = {isa = PBXBuildFile; fileRef = F10000000000000000000002 /* CodexBar Helper Debug.app */; };
+ F10000000000000000000001 /* CodexBar Power Helper.app in Embed Power Helper Manager */ = {isa = PBXBuildFile; fileRef = F10000000000000000000014 /* CodexBar Power Helper.app */; };
/* End PBXBuildFile section */
/* Begin PBXContainerItemProxy section */
@@ -19,26 +19,26 @@
containerPortal = C4A0FD8D2FD9302E000263A7 /* Project object */;
proxyType = 1;
remoteGlobalIDString = B10000000000000000000031;
- remoteInfo = CodexBarHelper;
+ remoteInfo = CodexBarPowerHelper;
};
F10000000000000000000007 /* PBXContainerItemProxy */ = {
isa = PBXContainerItemProxy;
containerPortal = C4A0FD8D2FD9302E000263A7 /* Project object */;
proxyType = 1;
remoteGlobalIDString = F10000000000000000000010;
- remoteInfo = CodexBarHelperManager;
+ remoteInfo = CodexBarPowerHelperManager;
};
/* End PBXContainerItemProxy section */
/* Begin PBXCopyFilesBuildPhase section */
- B10000000000000000000023 /* Embed CodexBar Helper */ = {
+ B10000000000000000000023 /* Embed CodexBar Power Helper */ = {
isa = PBXCopyFilesBuildPhase;
- dstPath = "";
- dstSubfolder = Resources;
+ dstPath = Contents/Helpers;
+ dstSubfolder = Wrapper;
files = (
- B10000000000000000000005 /* CodexBarHelper in Embed CodexBar Helper */,
+ B10000000000000000000005 /* CodexBarPowerHelper in Embed CodexBar Power Helper */,
);
- name = "Embed CodexBar Helper";
+ name = "Embed CodexBar Power Helper";
};
B10000000000000000000024 /* Copy LaunchDaemons */ = {
isa = PBXCopyFilesBuildPhase;
@@ -48,24 +48,25 @@
);
name = "Copy LaunchDaemons";
};
- F10000000000000000000004 /* Embed Helper Manager */ = {
+ F10000000000000000000004 /* Embed Power Helper Manager */ = {
isa = PBXCopyFilesBuildPhase;
dstPath = Contents/Helpers;
dstSubfolder = Wrapper;
files = (
- F10000000000000000000001 /* CodexBar Helper Debug.app in Embed Helper Manager */,
+ F10000000000000000000001 /* CodexBar Power Helper.app in Embed Power Helper Manager */,
);
- name = "Embed Helper Manager";
+ name = "Embed Power Helper Manager";
};
/* End PBXCopyFilesBuildPhase section */
/* Begin PBXFileReference section */
- B10000000000000000000014 /* CodexBarHelper */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = CodexBarHelper; sourceTree = BUILT_PRODUCTS_DIR; };
+ B10000000000000000000014 /* CodexBarPowerHelper */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = CodexBarPowerHelper; sourceTree = BUILT_PRODUCTS_DIR; };
C449FB5030203E0000ED2123 /* Version.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = Version.xcconfig; sourceTree = "<group>"; };
C4A0FD952FD9302E000263A7 /* CodexBar Debug.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = "CodexBar Debug.app"; sourceTree = BUILT_PRODUCTS_DIR; };
D10000000000000000000002 /* CodexBarTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = CodexBarTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; };
- E10000000000000000000002 /* CodexBarHelperTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = CodexBarHelperTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; };
- F10000000000000000000002 /* CodexBar Helper Debug.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = "CodexBar Helper Debug.app"; sourceTree = BUILT_PRODUCTS_DIR; };
+ E10000000000000000000002 /* CodexBarPowerHelperTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = CodexBarPowerHelperTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; };
+ F10000000000000000000002 /* CodexBar Power Helper Debug.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = "CodexBar Power Helper Debug.app"; sourceTree = BUILT_PRODUCTS_DIR; };
+ F10000000000000000000014 /* CodexBar Power Helper.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; name = "CodexBar Power Helper.app"; path = "$(CODEXBAR_POWER_HELPER_MANAGER_WRAPPER_NAME)"; sourceTree = BUILT_PRODUCTS_DIR; };
/* End PBXFileReference section */
/* Begin PBXFileSystemSynchronizedBuildFileExceptionSet section */
@@ -76,30 +77,92 @@
);
target = C4A0FD942FD9302E000263A7 /* CodexBar */;
};
- D10000000000000000000003 /* Exceptions for "CodexBar" folder in "CodexBarTests" target */ = {
+ C4A0F93C3080B50A00F73F58 /* Exceptions for "CodexBarHelper" folder in "CodexBarPowerHelperManager" target */ = {
isa = PBXFileSystemSynchronizedBuildFileExceptionSet;
membershipExceptions = (
- Resources/AppIcon.icon,
- Resources/Info.plist,
+ Power/Manager/PowerHelperManagerMain.swift,
+ Power/Manager/Resources/AppIcon.icon,
+ Power/Shared/CodexBarPowerHelperXPC.swift,
+ Power/Shared/PowerHelperManagement.swift,
+ );
+ target = F10000000000000000000010 /* CodexBarPowerHelperManager */;
+ };
+ C4A0F93E3080B50A00F73F58 /* Exceptions for "CodexBarHelper" folder in "CodexBarPowerHelperTests" target */ = {
+ isa = PBXFileSystemSynchronizedBuildFileExceptionSet;
+ membershipExceptions = (
+ Power/Daemon/OwnershipStore.swift,
+ Power/Daemon/Pmset.swift,
+ Power/Daemon/PowerHelperError.swift,
+ Power/Daemon/PowerHelperRuntime.swift,
+ Power/Shared/CodexBarPowerHelperXPC.swift,
+ Power/Shared/PowerHelperManagement.swift,
+ );
+ target = E10000000000000000000010 /* CodexBarPowerHelperTests */;
+ };
+ C4A0F93F3080B50A00F73F58 /* Exceptions for "CodexBarHelper" folder in "CodexBarTests" target */ = {
+ isa = PBXFileSystemSynchronizedBuildFileExceptionSet;
+ membershipExceptions = (
+ Power/Shared/CodexBarPowerHelperXPC.swift,
+ Power/Shared/PowerHelperManagement.swift,
);
target = D10000000000000000000010 /* CodexBarTests */;
};
- E10000000000000000000003 /* Exceptions for "CodexBarHelper" folder in "CodexBarHelperTests" target */ = {
+ C4A0F9403080B50A00F73F58 /* Exceptions for "CodexBarHelper" folder in "CodexBar" target */ = {
isa = PBXFileSystemSynchronizedBuildFileExceptionSet;
membershipExceptions = (
- main.swift,
+ Power/Shared/CodexBarPowerHelperXPC.swift,
+ Power/Shared/PowerHelperManagement.swift,
);
- target = E10000000000000000000010 /* CodexBarHelperTests */;
+ target = C4A0FD942FD9302E000263A7 /* CodexBar */;
+ };
+ C4A0F9413080B50A00F73F58 /* Exceptions for "CodexBarHelper" folder in "CodexBarPowerHelper" target */ = {
+ isa = PBXFileSystemSynchronizedBuildFileExceptionSet;
+ membershipExceptions = (
+ Power/Daemon/main.swift,
+ Power/Daemon/OwnershipStore.swift,
+ Power/Daemon/Pmset.swift,
+ Power/Daemon/PowerHelperError.swift,
+ Power/Daemon/PowerHelperRuntime.swift,
+ Power/Shared/CodexBarPowerHelperXPC.swift,
+ Power/Shared/PowerHelperManagement.swift,
+ );
+ target = B10000000000000000000031 /* CodexBarPowerHelper */;
+ };
+ C4A0F9C93080B50F00F73F58 /* Exceptions for "Tests" folder in "CodexBarPowerHelperTests" target */ = {
+ isa = PBXFileSystemSynchronizedBuildFileExceptionSet;
+ membershipExceptions = (
+ Helpers/Power/PowerHelperSleepTests.swift,
+ Helpers/Power/PowerHelperTestSupport.swift,
+ Helpers/Power/PowerHelperUpdateTests.swift,
+ );
+ target = E10000000000000000000010 /* CodexBarPowerHelperTests */;
+ };
+ C4A0F9CA3080B50F00F73F58 /* Exceptions for "Tests" folder in "CodexBarTests" target */ = {
+ isa = PBXFileSystemSynchronizedBuildFileExceptionSet;
+ membershipExceptions = (
+ Helpers/Power/PowerHelperSleepTests.swift,
+ Helpers/Power/PowerHelperTestSupport.swift,
+ Helpers/Power/PowerHelperUpdateTests.swift,
+ );
+ target = D10000000000000000000010 /* CodexBarTests */;
+ };
+ D10000000000000000000003 /* Exceptions for "CodexBar" folder in "CodexBarTests" target */ = {
+ isa = PBXFileSystemSynchronizedBuildFileExceptionSet;
+ membershipExceptions = (
+ Resources/AppIcon.icon,
+ Resources/Info.plist,
+ );
+ target = D10000000000000000000010 /* CodexBarTests */;
};
/* End PBXFileSystemSynchronizedBuildFileExceptionSet section */
/* Begin PBXFileSystemSynchronizedGroupBuildPhaseMembershipExceptionSet section */
- C449FB4C302038A300ED2123 /* Exceptions for "CodexBarHelper" folder in "Copy LaunchDaemons" phase from "CodexBarHelperManager" target */ = {
+ C4A0F93D3080B50A00F73F58 /* Exceptions for "CodexBarHelper" folder in "Copy LaunchDaemons" phase from "CodexBarPowerHelperManager" target */ = {
isa = PBXFileSystemSynchronizedGroupBuildPhaseMembershipExceptionSet;
buildPhase = B10000000000000000000024 /* Copy LaunchDaemons */;
membershipExceptions = (
- app.zabrian.codexbar.helper.debug.plist,
- app.zabrian.codexbar.helper.plist,
+ Power/Daemon/CodexBarPowerHelper.Debug.plist,
+ Power/Daemon/CodexBarPowerHelper.plist,
);
};
/* End PBXFileSystemSynchronizedGroupBuildPhaseMembershipExceptionSet section */
@@ -114,33 +177,31 @@
path = CodexBar;
sourceTree = "<group>";
};
- C449FB3A3020367500ED2123 /* CodexBarHelper */ = {
- isa = PBXFileSystemSynchronizedRootGroup;
- exceptions = (
- C449FB4C302038A300ED2123 /* Exceptions for "CodexBarHelper" folder in "Copy LaunchDaemons" phase from "CodexBarHelperManager" target */,
- E10000000000000000000003 /* Exceptions for "CodexBarHelper" folder in "CodexBarHelperTests" target */,
- );
- path = CodexBarHelper;
- sourceTree = "<group>";
- };
C449FB4E30203A1100ED2123 /* Shared */ = {
isa = PBXFileSystemSynchronizedRootGroup;
path = Shared;
sourceTree = "<group>";
};
- D10000000000000000000004 /* CodexBarTests */ = {
- isa = PBXFileSystemSynchronizedRootGroup;
- path = CodexBarTests;
- sourceTree = "<group>";
- };
- E10000000000000000000004 /* CodexBarHelperTests */ = {
+ C4A0F9243080B50900F73F58 /* CodexBarHelper */ = {
isa = PBXFileSystemSynchronizedRootGroup;
- path = CodexBarHelperTests;
+ exceptions = (
+ C4A0F93C3080B50A00F73F58 /* Exceptions for "CodexBarHelper" folder in "CodexBarPowerHelperManager" target */,
+ C4A0F93D3080B50A00F73F58 /* Exceptions for "CodexBarHelper" folder in "Copy LaunchDaemons" phase from "CodexBarPowerHelperManager" target */,
+ C4A0F93E3080B50A00F73F58 /* Exceptions for "CodexBarHelper" folder in "CodexBarPowerHelperTests" target */,
+ C4A0F93F3080B50A00F73F58 /* Exceptions for "CodexBarHelper" folder in "CodexBarTests" target */,
+ C4A0F9403080B50A00F73F58 /* Exceptions for "CodexBarHelper" folder in "CodexBar" target */,
+ C4A0F9413080B50A00F73F58 /* Exceptions for "CodexBarHelper" folder in "CodexBarPowerHelper" target */,
+ );
+ path = CodexBarHelper;
sourceTree = "<group>";
};
- F10000000000000000000003 /* CodexBarHelperManager */ = {
+ C4A0F98B3080B50E00F73F58 /* Tests */ = {
isa = PBXFileSystemSynchronizedRootGroup;
- path = CodexBarHelperManager;
+ exceptions = (
+ C4A0F9C93080B50F00F73F58 /* Exceptions for "Tests" folder in "CodexBarPowerHelperTests" target */,
+ C4A0F9CA3080B50F00F73F58 /* Exceptions for "Tests" folder in "CodexBarTests" target */,
+ );
+ path = Tests;
sourceTree = "<group>";
};
/* End PBXFileSystemSynchronizedRootGroup section */
@@ -188,11 +249,9 @@
isa = PBXGroup;
children = (
9E664A4C2FDD47530016B96E /* CodexBar */,
- F10000000000000000000003 /* CodexBarHelperManager */,
- D10000000000000000000004 /* CodexBarTests */,
- E10000000000000000000004 /* CodexBarHelperTests */,
+ C4A0F9243080B50900F73F58 /* CodexBarHelper */,
+ C4A0F98B3080B50E00F73F58 /* Tests */,
C449FB4E30203A1100ED2123 /* Shared */,
- C449FB3A3020367500ED2123 /* CodexBarHelper */,
C449FB5130203E0000ED2123 /* Config */,
C4A0FD962FD9302E000263A7 /* Products */,
);
@@ -203,9 +262,10 @@
children = (
C4A0FD952FD9302E000263A7 /* CodexBar Debug.app */,
D10000000000000000000002 /* CodexBarTests.xctest */,
- E10000000000000000000002 /* CodexBarHelperTests.xctest */,
- B10000000000000000000014 /* CodexBarHelper */,
- F10000000000000000000002 /* CodexBar Helper Debug.app */,
+ E10000000000000000000002 /* CodexBarPowerHelperTests.xctest */,
+ B10000000000000000000014 /* CodexBarPowerHelper */,
+ F10000000000000000000002 /* CodexBar Power Helper Debug.app */,
+ F10000000000000000000014 /* CodexBar Power Helper.app */,
);
name = Products;
sourceTree = "<group>";
@@ -213,9 +273,9 @@
/* End PBXGroup section */
/* Begin PBXNativeTarget section */
- B10000000000000000000031 /* CodexBarHelper */ = {
+ B10000000000000000000031 /* CodexBarPowerHelper */ = {
isa = PBXNativeTarget;
- buildConfigurationList = B10000000000000000000032 /* Build configuration list for PBXNativeTarget "CodexBarHelper" */;
+ buildConfigurationList = B10000000000000000000032 /* Build configuration list for PBXNativeTarget "CodexBarPowerHelper" */;
buildPhases = (
B10000000000000000000021 /* Sources */,
B10000000000000000000022 /* Frameworks */,
@@ -223,12 +283,11 @@
buildRules = (
);
fileSystemSynchronizedGroups = (
- C449FB3A3020367500ED2123 /* CodexBarHelper */,
C449FB4E30203A1100ED2123 /* Shared */,
);
- name = CodexBarHelper;
- productName = CodexBarHelper;
- productReference = B10000000000000000000014 /* CodexBarHelper */;
+ name = CodexBarPowerHelper;
+ productName = CodexBarPowerHelper;
+ productReference = B10000000000000000000014 /* CodexBarPowerHelper */;
productType = "com.apple.product-type.tool";
};
C4A0FD942FD9302E000263A7 /* CodexBar */ = {
@@ -238,7 +297,7 @@
C4A0FD912FD9302E000263A7 /* Sources */,
C4A0FD922FD9302E000263A7 /* Frameworks */,
C4A0FD932FD9302E000263A7 /* Resources */,
- F10000000000000000000004 /* Embed Helper Manager */,
+ F10000000000000000000004 /* Embed Power Helper Manager */,
);
buildRules = (
);
@@ -270,7 +329,7 @@
fileSystemSynchronizedGroups = (
9E664A4C2FDD47530016B96E /* CodexBar */,
C449FB4E30203A1100ED2123 /* Shared */,
- D10000000000000000000004 /* CodexBarTests */,
+ C4A0F98B3080B50E00F73F58 /* Tests */,
);
name = CodexBarTests;
packageProductDependencies = (
@@ -280,9 +339,9 @@
productReference = D10000000000000000000002 /* CodexBarTests.xctest */;
productType = "com.apple.product-type.bundle.unit-test";
};
- E10000000000000000000010 /* CodexBarHelperTests */ = {
+ E10000000000000000000010 /* CodexBarPowerHelperTests */ = {
isa = PBXNativeTarget;
- buildConfigurationList = E10000000000000000000011 /* Build configuration list for PBXNativeTarget "CodexBarHelperTests" */;
+ buildConfigurationList = E10000000000000000000011 /* Build configuration list for PBXNativeTarget "CodexBarPowerHelperTests" */;
buildPhases = (
E10000000000000000000006 /* Sources */,
E10000000000000000000005 /* Frameworks */,
@@ -290,23 +349,21 @@
buildRules = (
);
fileSystemSynchronizedGroups = (
- C449FB3A3020367500ED2123 /* CodexBarHelper */,
C449FB4E30203A1100ED2123 /* Shared */,
- E10000000000000000000004 /* CodexBarHelperTests */,
);
- name = CodexBarHelperTests;
- productName = CodexBarHelperTests;
- productReference = E10000000000000000000002 /* CodexBarHelperTests.xctest */;
+ name = CodexBarPowerHelperTests;
+ productName = CodexBarPowerHelperTests;
+ productReference = E10000000000000000000002 /* CodexBarPowerHelperTests.xctest */;
productType = "com.apple.product-type.bundle.unit-test";
};
- F10000000000000000000010 /* CodexBarHelperManager */ = {
+ F10000000000000000000010 /* CodexBarPowerHelperManager */ = {
isa = PBXNativeTarget;
- buildConfigurationList = F10000000000000000000011 /* Build configuration list for PBXNativeTarget "CodexBarHelperManager" */;
+ buildConfigurationList = F10000000000000000000011 /* Build configuration list for PBXNativeTarget "CodexBarPowerHelperManager" */;
buildPhases = (
F10000000000000000000005 /* Sources */,
F10000000000000000000006 /* Frameworks */,
F10000000000000000000009 /* Resources */,
- B10000000000000000000023 /* Embed CodexBar Helper */,
+ B10000000000000000000023 /* Embed CodexBar Power Helper */,
B10000000000000000000024 /* Copy LaunchDaemons */,
);
buildRules = (
@@ -316,11 +373,10 @@
);
fileSystemSynchronizedGroups = (
C449FB4E30203A1100ED2123 /* Shared */,
- F10000000000000000000003 /* CodexBarHelperManager */,
);
- name = CodexBarHelperManager;
- productName = CodexBarHelperManager;
- productReference = F10000000000000000000002 /* CodexBar Helper Debug.app */;
+ name = CodexBarPowerHelperManager;
+ productName = CodexBarPowerHelperManager;
+ productReference = F10000000000000000000002 /* CodexBar Power Helper Debug.app */;
productType = "com.apple.product-type.application";
};
/* End PBXNativeTarget section */
@@ -359,11 +415,11 @@
projectDirPath = "";
projectRoot = "";
targets = (
- F10000000000000000000010 /* CodexBarHelperManager */,
- E10000000000000000000010 /* CodexBarHelperTests */,
+ F10000000000000000000010 /* CodexBarPowerHelperManager */,
+ E10000000000000000000010 /* CodexBarPowerHelperTests */,
D10000000000000000000010 /* CodexBarTests */,
C4A0FD942FD9302E000263A7 /* CodexBar */,
- B10000000000000000000031 /* CodexBarHelper */,
+ B10000000000000000000031 /* CodexBarPowerHelper */,
);
};
/* End PBXProject section */
@@ -417,18 +473,18 @@
/* Begin PBXTargetDependency section */
B10000000000000000000051 /* PBXTargetDependency */ = {
isa = PBXTargetDependency;
- target = B10000000000000000000031 /* CodexBarHelper */;
+ target = B10000000000000000000031 /* CodexBarPowerHelper */;
targetProxy = B10000000000000000000052 /* PBXContainerItemProxy */;
};
F10000000000000000000008 /* PBXTargetDependency */ = {
isa = PBXTargetDependency;
- target = F10000000000000000000010 /* CodexBarHelperManager */;
+ target = F10000000000000000000010 /* CodexBarPowerHelperManager */;
targetProxy = F10000000000000000000007 /* PBXContainerItemProxy */;
};
/* End PBXTargetDependency section */
/* Begin XCBuildConfiguration section */
- B10000000000000000000033 /* Debug configuration for PBXNativeTarget "CodexBarHelper" */ = {
+ B10000000000000000000033 /* Debug configuration for PBXNativeTarget "CodexBarPowerHelper" */ = {
isa = XCBuildConfiguration;
buildSettings = {
"CODE_SIGN_IDENTITY[sdk=macosx*]" = "Apple Development";
@@ -437,14 +493,14 @@
ENABLE_APP_SANDBOX = NO;
ENABLE_HARDENED_RUNTIME = YES;
GENERATE_INFOPLIST_FILE = YES;
- PRODUCT_BUNDLE_IDENTIFIER = app.zabrian.codexbar.helper.debug;
+ PRODUCT_BUNDLE_IDENTIFIER = app.zabrian.codexbar.helper.power.debug;
PRODUCT_NAME = "$(TARGET_NAME)";
SKIP_INSTALL = YES;
SWIFT_UPCOMING_FEATURE_MEMBER_IMPORT_VISIBILITY = YES;
};
name = Debug;
};
- B10000000000000000000034 /* Release configuration for PBXNativeTarget "CodexBarHelper" */ = {
+ B10000000000000000000034 /* Release configuration for PBXNativeTarget "CodexBarPowerHelper" */ = {
isa = XCBuildConfiguration;
buildSettings = {
"CODE_SIGN_IDENTITY[sdk=macosx*]" = "Apple Development";
@@ -453,7 +509,7 @@
ENABLE_APP_SANDBOX = NO;
ENABLE_HARDENED_RUNTIME = YES;
GENERATE_INFOPLIST_FILE = YES;
- PRODUCT_BUNDLE_IDENTIFIER = app.zabrian.codexbar.helper;
+ PRODUCT_BUNDLE_IDENTIFIER = app.zabrian.codexbar.helper.power;
PRODUCT_NAME = "$(TARGET_NAME)";
SKIP_INSTALL = YES;
SWIFT_UPCOMING_FEATURE_MEMBER_IMPORT_VISIBILITY = YES;
@@ -495,6 +551,7 @@
CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE;
CLANG_WARN_UNREACHABLE_CODE = YES;
CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+ CODEXBAR_POWER_HELPER_MANAGER_WRAPPER_NAME = "CodexBar Power Helper Debug.app";
COPY_PHASE_STRIP = NO;
DEAD_CODE_STRIPPING = YES;
DEBUG_INFORMATION_FORMAT = dwarf;
@@ -564,6 +621,7 @@
CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE;
CLANG_WARN_UNREACHABLE_CODE = YES;
CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+ CODEXBAR_POWER_HELPER_MANAGER_WRAPPER_NAME = "CodexBar Power Helper.app";
CODE_SIGN_INJECT_BASE_ENTITLEMENTS = NO;
COPY_PHASE_STRIP = NO;
DEAD_CODE_STRIPPING = YES;
@@ -605,7 +663,7 @@
ENABLE_HARDENED_RUNTIME = YES;
ENABLE_PREVIEWS = YES;
ENABLE_USER_SELECTED_FILES = NO;
- EXCLUDED_SOURCE_FILE_NAMES = app.zabrian.codexbar.helper.plist;
+ EXCLUDED_SOURCE_FILE_NAMES = CodexBarPowerHelper.plist;
GENERATE_INFOPLIST_FILE = NO;
INFOPLIST_FILE = CodexBar/Resources/Info.plist;
INFOPLIST_KEY_CFBundleDisplayName = "CodexBar Debug";
@@ -638,7 +696,7 @@
ENABLE_HARDENED_RUNTIME = YES;
ENABLE_PREVIEWS = YES;
ENABLE_USER_SELECTED_FILES = NO;
- EXCLUDED_SOURCE_FILE_NAMES = app.zabrian.codexbar.helper.debug.plist;
+ EXCLUDED_SOURCE_FILE_NAMES = CodexBarPowerHelper.Debug.plist;
GENERATE_INFOPLIST_FILE = NO;
INFOPLIST_FILE = CodexBar/Resources/Info.plist;
INFOPLIST_KEY_CFBundleDisplayName = CodexBar;
@@ -701,13 +759,13 @@
};
name = Release;
};
- E10000000000000000000012 /* Debug configuration for PBXNativeTarget "CodexBarHelperTests" */ = {
+ E10000000000000000000012 /* Debug configuration for PBXNativeTarget "CodexBarPowerHelperTests" */ = {
isa = XCBuildConfiguration;
buildSettings = {
CODE_SIGN_STYLE = Automatic;
ENABLE_APP_SANDBOX = NO;
GENERATE_INFOPLIST_FILE = YES;
- PRODUCT_BUNDLE_IDENTIFIER = app.zabrian.codexbar.helper.tests;
+ PRODUCT_BUNDLE_IDENTIFIER = app.zabrian.codexbar.helper.power.tests;
PRODUCT_NAME = "$(TARGET_NAME)";
SKIP_INSTALL = YES;
SWIFT_EMIT_LOC_STRINGS = NO;
@@ -715,13 +773,13 @@
};
name = Debug;
};
- E10000000000000000000013 /* Release configuration for PBXNativeTarget "CodexBarHelperTests" */ = {
+ E10000000000000000000013 /* Release configuration for PBXNativeTarget "CodexBarPowerHelperTests" */ = {
isa = XCBuildConfiguration;
buildSettings = {
CODE_SIGN_STYLE = Automatic;
ENABLE_APP_SANDBOX = NO;
GENERATE_INFOPLIST_FILE = YES;
- PRODUCT_BUNDLE_IDENTIFIER = app.zabrian.codexbar.helper.tests;
+ PRODUCT_BUNDLE_IDENTIFIER = app.zabrian.codexbar.helper.power.tests;
PRODUCT_NAME = "$(TARGET_NAME)";
SKIP_INSTALL = YES;
SWIFT_EMIT_LOC_STRINGS = NO;
@@ -729,7 +787,7 @@
};
name = Release;
};
- F10000000000000000000012 /* Debug configuration for PBXNativeTarget "CodexBarHelperManager" */ = {
+ F10000000000000000000012 /* Debug configuration for PBXNativeTarget "CodexBarPowerHelperManager" */ = {
isa = XCBuildConfiguration;
buildSettings = {
ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
@@ -737,19 +795,19 @@
CODE_SIGN_STYLE = Automatic;
ENABLE_APP_SANDBOX = NO;
ENABLE_HARDENED_RUNTIME = YES;
- EXCLUDED_SOURCE_FILE_NAMES = app.zabrian.codexbar.helper.plist;
+ EXCLUDED_SOURCE_FILE_NAMES = CodexBarPowerHelper.plist;
GENERATE_INFOPLIST_FILE = YES;
- INFOPLIST_KEY_CFBundleDisplayName = "CodexBar Helper Debug";
+ INFOPLIST_KEY_CFBundleDisplayName = "CodexBar Power Helper Debug";
INFOPLIST_KEY_LSUIElement = YES;
- PRODUCT_BUNDLE_IDENTIFIER = "app.zabrian.codexbar.helper-manager.debug";
+ PRODUCT_BUNDLE_IDENTIFIER = app.zabrian.codexbar.helper.power.manager.debug;
PRODUCT_NAME = "$(TARGET_NAME)";
SKIP_INSTALL = YES;
SWIFT_EMIT_LOC_STRINGS = NO;
- WRAPPER_NAME = "CodexBar Helper Debug.app";
+ WRAPPER_NAME = "$(CODEXBAR_POWER_HELPER_MANAGER_WRAPPER_NAME)";
};
name = Debug;
};
- F10000000000000000000013 /* Release configuration for PBXNativeTarget "CodexBarHelperManager" */ = {
+ F10000000000000000000013 /* Release configuration for PBXNativeTarget "CodexBarPowerHelperManager" */ = {
isa = XCBuildConfiguration;
buildSettings = {
ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
@@ -757,26 +815,26 @@
CODE_SIGN_STYLE = Automatic;
ENABLE_APP_SANDBOX = NO;
ENABLE_HARDENED_RUNTIME = YES;
- EXCLUDED_SOURCE_FILE_NAMES = app.zabrian.codexbar.helper.debug.plist;
+ EXCLUDED_SOURCE_FILE_NAMES = CodexBarPowerHelper.Debug.plist;
GENERATE_INFOPLIST_FILE = YES;
- INFOPLIST_KEY_CFBundleDisplayName = "CodexBar Helper";
+ INFOPLIST_KEY_CFBundleDisplayName = "CodexBar Power Helper";
INFOPLIST_KEY_LSUIElement = YES;
- PRODUCT_BUNDLE_IDENTIFIER = "app.zabrian.codexbar.helper-manager";
+ PRODUCT_BUNDLE_IDENTIFIER = app.zabrian.codexbar.helper.power.manager;
PRODUCT_NAME = "$(TARGET_NAME)";
SKIP_INSTALL = YES;
SWIFT_EMIT_LOC_STRINGS = NO;
- WRAPPER_NAME = "CodexBar Helper.app";
+ WRAPPER_NAME = "$(CODEXBAR_POWER_HELPER_MANAGER_WRAPPER_NAME)";
};
name = Release;
};
/* End XCBuildConfiguration section */
/* Begin XCConfigurationList section */
- B10000000000000000000032 /* Build configuration list for PBXNativeTarget "CodexBarHelper" */ = {
+ B10000000000000000000032 /* Build configuration list for PBXNativeTarget "CodexBarPowerHelper" */ = {
isa = XCConfigurationList;
buildConfigurations = (
- B10000000000000000000033 /* Debug configuration for PBXNativeTarget "CodexBarHelper" */,
- B10000000000000000000034 /* Release configuration for PBXNativeTarget "CodexBarHelper" */,
+ B10000000000000000000033 /* Debug configuration for PBXNativeTarget "CodexBarPowerHelper" */,
+ B10000000000000000000034 /* Release configuration for PBXNativeTarget "CodexBarPowerHelper" */,
);
defaultConfigurationName = Release;
};
@@ -804,19 +862,19 @@
);
defaultConfigurationName = Release;
};
- E10000000000000000000011 /* Build configuration list for PBXNativeTarget "CodexBarHelperTests" */ = {
+ E10000000000000000000011 /* Build configuration list for PBXNativeTarget "CodexBarPowerHelperTests" */ = {
isa = XCConfigurationList;
buildConfigurations = (
- E10000000000000000000012 /* Debug configuration for PBXNativeTarget "CodexBarHelperTests" */,
- E10000000000000000000013 /* Release configuration for PBXNativeTarget "CodexBarHelperTests" */,
+ E10000000000000000000012 /* Debug configuration for PBXNativeTarget "CodexBarPowerHelperTests" */,
+ E10000000000000000000013 /* Release configuration for PBXNativeTarget "CodexBarPowerHelperTests" */,
);
defaultConfigurationName = Release;
};
- F10000000000000000000011 /* Build configuration list for PBXNativeTarget "CodexBarHelperManager" */ = {
+ F10000000000000000000011 /* Build configuration list for PBXNativeTarget "CodexBarPowerHelperManager" */ = {
isa = XCConfigurationList;
buildConfigurations = (
- F10000000000000000000012 /* Debug configuration for PBXNativeTarget "CodexBarHelperManager" */,
- F10000000000000000000013 /* Release configuration for PBXNativeTarget "CodexBarHelperManager" */,
+ F10000000000000000000012 /* Debug configuration for PBXNativeTarget "CodexBarPowerHelperManager" */,
+ F10000000000000000000013 /* Release configuration for PBXNativeTarget "CodexBarPowerHelperManager" */,
);
defaultConfigurationName = Release;
};
diff --git a/CodexBar.xcodeproj/xcshareddata/xcschemes/CodexBar.xcscheme b/CodexBar.xcodeproj/xcshareddata/xcschemes/CodexBar.xcscheme
index e3e9cb1..0807655 100644
--- a/CodexBar.xcodeproj/xcshareddata/xcschemes/CodexBar.xcscheme
+++ b/CodexBar.xcodeproj/xcshareddata/xcschemes/CodexBar.xcscheme
@@ -44,8 +44,8 @@
<TestableReference skipped = "NO" parallelizable = "NO">
<BuildableReference BuildableIdentifier = "primary"
BlueprintIdentifier = "E10000000000000000000010"
- BuildableName = "CodexBarHelperTests.xctest"
- BlueprintName = "CodexBarHelperTests"
+ BuildableName = "CodexBarPowerHelperTests.xctest"
+ BlueprintName = "CodexBarPowerHelperTests"
ReferencedContainer = "container:CodexBar.xcodeproj">
</BuildableReference>
</TestableReference>
diff --git a/CodexBar.xcodeproj/xcuserdata/bob.xcuserdatad/xcschemes/xcschememanagement.plist b/CodexBar.xcodeproj/xcuserdata/bob.xcuserdatad/xcschemes/xcschememanagement.plist
index d8e6cbe..2c4df98 100644
--- a/CodexBar.xcodeproj/xcuserdata/bob.xcuserdatad/xcschemes/xcschememanagement.plist
+++ b/CodexBar.xcodeproj/xcuserdata/bob.xcuserdatad/xcschemes/xcschememanagement.plist
@@ -9,12 +9,12 @@
<key>orderHint</key>
<integer>0</integer>
</dict>
- <key>CodexBarHelper.xcscheme_^#shared#^_</key>
+ <key>CodexBarPowerHelper.xcscheme_^#shared#^_</key>
<dict>
<key>orderHint</key>
<integer>1</integer>
</dict>
- <key>CodexBarHelperManager.xcscheme_^#shared#^_</key>
+ <key>CodexBarPowerHelperManager.xcscheme_^#shared#^_</key>
<dict>
<key>orderHint</key>
<integer>2</integer>
diff --git a/CodexBar/Resources/Localizable.xcstrings b/CodexBar/Resources/Localizable.xcstrings
index 4549ff4..5c7a114 100644
--- a/CodexBar/Resources/Localizable.xcstrings
+++ b/CodexBar/Resources/Localizable.xcstrings
@@ -3105,39 +3105,39 @@
}
}
},
- "helper.error.assets-invalid" : {
+ "power-helper.error.assets-invalid" : {
"localizations" : {
"en" : {
"stringUnit" : {
"state" : "translated",
- "value" : "CodexBar Helper is invalid"
+ "value" : "CodexBar Power Helper is invalid"
}
},
"zh-Hans" : {
"stringUnit" : {
"state" : "translated",
- "value" : "CodexBar Helper 组件或配置异常"
+ "value" : "CodexBar Power Helper 组件或配置异常"
}
}
}
},
- "helper.error.assets-missing" : {
+ "power-helper.error.assets-missing" : {
"localizations" : {
"en" : {
"stringUnit" : {
"state" : "translated",
- "value" : "CodexBar Helper is missing"
+ "value" : "CodexBar Power Helper is missing"
}
},
"zh-Hans" : {
"stringUnit" : {
"state" : "translated",
- "value" : "CodexBar Helper 组件或配置丢失"
+ "value" : "CodexBar Power Helper 组件或配置丢失"
}
}
}
},
- "helper.error.connection-failed" : {
+ "power-helper.error.connection-failed" : {
"localizations" : {
"en" : {
"stringUnit" : {
@@ -3153,7 +3153,7 @@
}
}
},
- "helper.error.connection-interrupted" : {
+ "power-helper.error.connection-interrupted" : {
"localizations" : {
"en" : {
"stringUnit" : {
@@ -3169,7 +3169,7 @@
}
}
},
- "helper.error.invalid-interface" : {
+ "power-helper.error.invalid-interface" : {
"localizations" : {
"en" : {
"stringUnit" : {
@@ -3185,7 +3185,7 @@
}
}
},
- "helper.error.no-response" : {
+ "power-helper.error.no-response" : {
"localizations" : {
"en" : {
"stringUnit" : {
@@ -3201,7 +3201,7 @@
}
}
},
- "helper.error.registration-failed" : {
+ "power-helper.error.registration-failed" : {
"localizations" : {
"en" : {
"stringUnit" : {
@@ -3217,7 +3217,7 @@
}
}
},
- "helper.error.update-failed" : {
+ "power-helper.error.update-failed" : {
"localizations" : {
"en" : {
"stringUnit" : {
@@ -3233,66 +3233,66 @@
}
}
},
- "helper.status.authorization-required" : {
+ "power-helper.status.authorization-required" : {
"localizations" : {
"en" : {
"stringUnit" : {
"state" : "translated",
- "value" : "Allow CodexBar Helper to run in the background"
+ "value" : "Allow CodexBar Power Helper to run in the background"
}
},
"zh-Hans" : {
"stringUnit" : {
"state" : "translated",
- "value" : "需要授权允许 CodexBar Helper 后台运行"
+ "value" : "需要授权允许 CodexBar Power Helper 后台运行"
}
}
}
},
- "helper.status.install-and-authorize" : {
+ "power-helper.status.install-and-authorize" : {
"localizations" : {
"en" : {
"stringUnit" : {
"state" : "translated",
- "value" : "Install CodexBar Helper and allow background activity"
+ "value" : "Install CodexBar Power Helper and allow background activity"
}
},
"zh-Hans" : {
"stringUnit" : {
"state" : "translated",
- "value" : "需要安装并授权 CodexBar Helper 后台运行"
+ "value" : "需要安装并授权 CodexBar Power Helper 后台运行"
}
}
}
},
- "helper.status.installed-needs-authorization" : {
+ "power-helper.status.installed-needs-authorization" : {
"localizations" : {
"en" : {
"stringUnit" : {
"state" : "translated",
- "value" : "CodexBar Helper installed. Allow background activity"
+ "value" : "CodexBar Power Helper installed. Allow background activity"
}
},
"zh-Hans" : {
"stringUnit" : {
"state" : "translated",
- "value" : "已安装 CodexBar Helper 但需要授权允许后台运行"
+ "value" : "已安装 CodexBar Power Helper 但需要授权允许后台运行"
}
}
}
},
- "helper.status.not-registered" : {
+ "power-helper.status.not-registered" : {
"localizations" : {
"en" : {
"stringUnit" : {
"state" : "translated",
- "value" : "CodexBarHelper is not registered"
+ "value" : "CodexBar Power Helper is not registered"
}
},
"zh-Hans" : {
"stringUnit" : {
"state" : "translated",
- "value" : "CodexBarHelper 尚未注册"
+ "value" : "CodexBar Power Helper 尚未注册"
}
}
}
@@ -4630,13 +4630,13 @@
"en" : {
"stringUnit" : {
"state" : "translated",
- "value" : "Default"
+ "value" : "System"
}
},
"zh-Hans" : {
"stringUnit" : {
"state" : "translated",
- "value" : "默认"
+ "value" : "系统"
}
}
}
@@ -4929,7 +4929,7 @@
}
}
},
- "settings.about.helper.authorized" : {
+ "settings.about.power-helper.authorized" : {
"localizations" : {
"en" : {
"stringUnit" : {
@@ -4945,7 +4945,7 @@
}
}
},
- "settings.about.helper.not-installed" : {
+ "settings.about.power-helper.not-installed" : {
"localizations" : {
"en" : {
"stringUnit" : {
@@ -4961,7 +4961,7 @@
}
}
},
- "settings.about.helper.requires-approval" : {
+ "settings.about.power-helper.requires-approval" : {
"localizations" : {
"en" : {
"stringUnit" : {
@@ -4977,23 +4977,23 @@
}
}
},
- "settings.about.helper.title" : {
+ "settings.about.power-helper.title" : {
"localizations" : {
"en" : {
"stringUnit" : {
"state" : "translated",
- "value" : "CodexBar Helper"
+ "value" : "CodexBar Power Helper"
}
},
"zh-Hans" : {
"stringUnit" : {
"state" : "translated",
- "value" : "CodexBar Helper"
+ "value" : "CodexBar Power Helper"
}
}
}
},
- "settings.about.helper.unavailable" : {
+ "settings.about.power-helper.unavailable" : {
"localizations" : {
"en" : {
"stringUnit" : {
diff --git a/CodexBar/Services/KeepAlive/AutoResetWakeScheduler.swift b/CodexBar/Services/KeepAlive/AutoResetWakeScheduler.swift
index f19ee1d..6b2692f 100644
--- a/CodexBar/Services/KeepAlive/AutoResetWakeScheduler.swift
+++ b/CodexBar/Services/KeepAlive/AutoResetWakeScheduler.swift
@@ -28,14 +28,14 @@ final class AutoResetWakeScheduler {
private enum PreparationState {
case none
case termination
- case helperInterruption
+ case powerHelperInterruption
}
var onErrorMessageChanged: ((String?) -> Void)?
- private let runtimeStatusMonitor = HelperStatusMonitor()
+ private let runtimeStatusMonitor = PowerHelperStatusMonitor()
private var isRequested = false
- private var isHelperReady = false
+ private var isPowerHelperReady = false
private var desiredWakeDate: Date?
private var appliedSchedule = AppliedSchedule.unknown
private var syncTask: Task<Void, Never>?
@@ -79,15 +79,15 @@ final class AutoResetWakeScheduler {
restartSyncForDesiredStateChange()
}
- func setHelperReady(_ ready: Bool) {
- guard ready != isHelperReady else {
+ func setPowerHelperReady(_ ready: Bool) {
+ guard ready != isPowerHelperReady else {
if ready {
reconcile()
}
return
}
- isHelperReady = ready
+ isPowerHelperReady = ready
guard ready else {
errorMessage = nil
suspend()
@@ -98,21 +98,21 @@ final class AutoResetWakeScheduler {
func stop() {
isRequested = false
- isHelperReady = false
+ isPowerHelperReady = false
preparationState = .none
desiredWakeDate = nil
errorMessage = nil
suspend()
}
- func prepareForTermination(helperSupportsWakeScheduling: Bool) async -> Bool {
+ func prepareForTermination(powerHelperSupportsWakeScheduling: Bool) async -> Bool {
guard preparationState == .none else {
return false
}
preparationState = .termination
cancelSyncTask()
- guard helperSupportsWakeScheduling || connection != nil else {
+ guard powerHelperSupportsWakeScheduling || connection != nil else {
return !appliedSchedule.hasWakeDate
}
return await cancelOwnedSchedule(reason: "termination")
@@ -127,28 +127,28 @@ final class AutoResetWakeScheduler {
reconcile()
}
- func beginHelperInterruptionPreparation() -> Bool {
+ func beginPowerHelperInterruptionPreparation() -> Bool {
guard preparationState == .none else {
return false
}
- preparationState = .helperInterruption
+ preparationState = .powerHelperInterruption
cancelSyncTask()
return true
}
- func cancelBeforeHelperInterruption() async -> Bool {
- guard preparationState == .helperInterruption else {
+ func cancelBeforePowerHelperInterruption() async -> Bool {
+ guard preparationState == .powerHelperInterruption else {
return false
}
guard connection != nil || appliedSchedule.hasWakeDate else {
return true
}
- return await cancelOwnedSchedule(reason: "helperUpdate")
+ return await cancelOwnedSchedule(reason: "powerHelperUpdate")
}
- func resumeAfterHelperInterruption() {
- guard preparationState == .helperInterruption else {
+ func resumeAfterPowerHelperInterruption() {
+ guard preparationState == .powerHelperInterruption else {
return
}
@@ -179,7 +179,7 @@ final class AutoResetWakeScheduler {
guard preparationState == .none else {
return
}
- guard isHelperReady else {
+ guard isPowerHelperReady else {
return
}
guard syncTask == nil else {
@@ -204,7 +204,7 @@ final class AutoResetWakeScheduler {
}
private func cancelOwnedSchedule(reason: String) async -> Bool {
- for delay in HelperConfiguration.wakeCancellationRetryDelays {
+ for delay in PowerHelperConfiguration.wakeCancellationRetryDelays {
if delay > .zero {
try? await Task.sleep(for: delay)
}
@@ -215,7 +215,7 @@ final class AutoResetWakeScheduler {
let result = await runtimeStatusMonitor.setAutoResetWakeSchedule(
connection: connection ?? makeConnection(),
unixTimestamp: 0,
- timeout: HelperConfiguration.requestTimeout
+ timeout: PowerHelperConfiguration.requestTimeout
)
guard !Task.isCancelled else {
return false
@@ -231,7 +231,7 @@ final class AutoResetWakeScheduler {
)
return true
- case let .helperFailure(code):
+ case let .powerHelperFailure(code):
AppLog.keepAlive.error(
"自动重置唤醒计划取消失败: reason=\(reason, privacy: .public) code=\(code)"
)
@@ -261,7 +261,7 @@ final class AutoResetWakeScheduler {
private func synchronizeSchedule() async {
var retryIndex = 0
- while !Task.isCancelled, isHelperReady {
+ while !Task.isCancelled, isPowerHelperReady {
guard appliedSchedule != AppliedSchedule(wakeDate: desiredWakeDate) else {
return
}
@@ -270,9 +270,9 @@ final class AutoResetWakeScheduler {
let result = await runtimeStatusMonitor.setAutoResetWakeSchedule(
connection: connection ?? makeConnection(),
unixTimestamp: requestedDate?.timeIntervalSince1970 ?? 0,
- timeout: HelperConfiguration.requestTimeout
+ timeout: PowerHelperConfiguration.requestTimeout
)
- guard !Task.isCancelled, isHelperReady else {
+ guard !Task.isCancelled, isPowerHelperReady else {
return
}
@@ -288,7 +288,7 @@ final class AutoResetWakeScheduler {
case .cancelled:
continue
- case let .helperFailure(code):
+ case let .powerHelperFailure(code):
AppLog.keepAlive.error("自动重置唤醒计划同步失败: code=\(code)")
case let .connectionFailure(error):
@@ -304,11 +304,11 @@ final class AutoResetWakeScheduler {
appliedSchedule = .unknown
errorMessage = KeepAliveLocalizedMessage.autoResetWakeScheduleFailed
- guard retryIndex < HelperConfiguration.wakeScheduleRetryDelays.count else {
+ guard retryIndex < PowerHelperConfiguration.wakeScheduleRetryDelays.count else {
return
}
- let delay = HelperConfiguration.wakeScheduleRetryDelays[retryIndex]
+ let delay = PowerHelperConfiguration.wakeScheduleRetryDelays[retryIndex]
retryIndex += 1
try? await Task.sleep(for: delay)
}
@@ -341,10 +341,10 @@ final class AutoResetWakeScheduler {
private func makeConnection() -> NSXPCConnection {
let connection = NSXPCConnection(
- machServiceName: CodexBarHelperIPC.machServiceName,
+ machServiceName: CodexBarPowerHelperIPC.serviceIdentifier,
options: .privileged
)
- connection.remoteObjectInterface = NSXPCInterface(with: CodexBarHelperProtocol.self)
+ connection.remoteObjectInterface = NSXPCInterface(with: CodexBarPowerHelperProtocol.self)
connection.invalidationHandler = { [weak self, weak connection] in
Task { @MainActor in
self?.handleConnectionLoss(connection, reason: "invalidated")
diff --git a/CodexBar/Services/KeepAlive/KeepAliveController.swift b/CodexBar/Services/KeepAlive/KeepAliveController.swift
index 11221b9..f70d57a 100644
--- a/CodexBar/Services/KeepAlive/KeepAliveController.swift
+++ b/CodexBar/Services/KeepAlive/KeepAliveController.swift
@@ -8,7 +8,7 @@ import ServiceManagement
@MainActor
final class KeepAliveController: ObservableObject {
@Published private(set) var isEnabled: Bool
- @Published private(set) var helperStatus = HelperStatus.notRegistered
+ @Published private(set) var powerHelperStatus = PowerHelperStatus.notRegistered
@Published private(set) var isPreventingSleep = false
@Published private(set) var sleepPreventionSource = CodexBarSleepPreventionSource.none
@Published private(set) var lowBatteryThreshold: LowBatteryThreshold
@@ -38,25 +38,25 @@ final class KeepAliveController: ObservableObject {
/// 只供自动重置设置行展示, 不与防睡眠操作错误混在一起
@Published private(set) var autoResetWakeScheduleErrorMessage: String?
- /// helper 安装与注册状态的错误, 注册恢复正常时才清除
+ /// Power Helper 安装与注册状态的错误, 注册恢复正常时才清除
@Published private var registrationErrorMessage: String?
/// 切换睡眠状态过程中的错误, 由下一次操作结果 用户动作或明确的依赖失效覆盖
- /// 与注册类错误分开存储: refreshHelperStatus 每次 App 激活都会跑, 不能抹掉操作结果
+ /// 与注册类错误分开存储: refreshPowerHelperStatus 每次 App 激活都会跑, 不能抹掉操作结果
@Published private var operationErrorMessage: String?
/// 注册不成功时操作类错误只是下游噪音, 优先展示注册问题
var errorMessage: String? {
- (isEnabled ? helperRegistrationErrorMessage : nil) ?? operationErrorMessage
+ (isEnabled ? powerHelperRegistrationErrorMessage : nil) ?? operationErrorMessage
}
- var helperRegistrationErrorMessage: String? {
- helperPackageValidation.issue?.message ?? registrationErrorMessage
+ var powerHelperRegistrationErrorMessage: String? {
+ powerHelperPackageValidation.issue?.message ?? registrationErrorMessage
}
- var helperInstallationStatus: HelperInstallationStatus {
- HelperInstallationStatus(
- registration: helperStatus,
- packageIssue: helperPackageValidation.issue,
+ var powerHelperInstallationStatus: PowerHelperInstallationStatus {
+ PowerHelperInstallationStatus(
+ registration: powerHelperStatus,
+ packageIssue: powerHelperPackageValidation.issue,
registrationError: registrationErrorMessage
)
}
@@ -80,9 +80,9 @@ final class KeepAliveController: ObservableObject {
/// 时长上限本身是粘滞状态, 每个计时周期天然只会进入一次
var onKeepAliveLimitTriggered: ((MaximumDuration) async -> Bool)?
- /// 用户开关仍开着, 且 helper 已经真的把睡眠关掉
+ /// 用户开关仍开着, 且 Power Helper 已经真的把睡眠关掉
/// isPreventingSleep 在稳态下已隐含 isEnabled (shouldDisableSleep 要求它)
- /// 叠这一层是为了关开关到 helper 回调之间的异步空窗: 用户意图先落地
+ /// 叠这一层是为了关开关到 Power Helper 回调之间的异步空窗: 用户意图先落地
var isActivelyPreventingSleep: Bool {
isEnabled && isPreventingSleep
}
@@ -97,27 +97,27 @@ final class KeepAliveController: ObservableObject {
private var runningTaskIDs = Set<UUID>()
/// 开着 keepsAwakeWhileWaiting 时, 等待任务也参与防睡眠判定
private var waitingTaskIDs = Set<UUID>()
- /// 同一 App 进程内跨 XPC 重连保持不变, helper 据此把连接变化与租约所有权分开
- private let helperClientSessionID = UUID().uuidString
+ /// 同一 App 进程内跨 XPC 重连保持不变, Power Helper 据此把连接变化与租约所有权分开
+ private let powerHelperClientSessionID = UUID().uuidString
private var connection: NSXPCConnection?
private var appliedSleepPreventionRequested: Bool?
- /// true 请求可能已被 helper 接收却丢了回复, 只有一次成功的 false 才能清除这个可能性
- private var mayHaveHelperLease = false
+ /// true 请求可能已被 Power Helper 接收却丢了回复, 只有一次成功的 false 才能清除这个可能性
+ private var mayHavePowerHelperLease = false
private var requestInFlight = false
private var requestGeneration: UInt64 = 0
private var pendingRequestCompletion: ((Bool) -> Void)?
private var retryTask: Task<Void, Never>?
private var requestTimeoutTask: Task<Void, Never>?
- private let helperStatusMonitor = HelperStatusMonitor()
- private let helperManager = HelperManagerClient()
- private var isHelperStatusAvailable = false
- private var helperFailureTask: Task<Void, Never>?
- private var helperLifecycleGeneration: UInt64 = 0
+ private let powerHelperStatusMonitor = PowerHelperStatusMonitor()
+ private let powerHelperManager = PowerHelperManagerClient()
+ private var isPowerHelperStatusAvailable = false
+ private var powerHelperFailureTask: Task<Void, Never>?
+ private var powerHelperLifecycleGeneration: UInt64 = 0
private var retryAttempt = 0
- private var helperRegistrationTask: Task<Void, Never>?
- private let helperPackageValidation = HelperPackageValidation()
+ private var powerHelperRegistrationTask: Task<Void, Never>?
+ private let powerHelperPackageValidation = PowerHelperPackageValidation()
/// 只经由派生状态影响 UI, 自己不发信号
- private var isRefreshingHelper = false
+ private var isRefreshingPowerHelper = false
private var isAutoResetRequested = false
private let autoResetWakeScheduler = AutoResetWakeScheduler()
/// 已排队但还没发出的低电量通知, 值是触及阈值时的电量
@@ -152,7 +152,7 @@ final class KeepAliveController: ObservableObject {
// 默认关闭: 它会让人离开后机器一直停在解锁状态, 这个取舍只能由用户自己做
keepsDisplayAwake = defaults.bool(forKey: Self.keepsDisplayAwakeKey)
activityMonitor.setProtectionEnabled(isEnabled)
- helperPackageValidation.onValidated = { [weak self] in
+ powerHelperPackageValidation.onValidated = { [weak self] in
guard let self, isStarted else { return }
refreshRegistrationAndSleepState(refreshPackage: false)
}
@@ -166,7 +166,7 @@ final class KeepAliveController: ObservableObject {
return
}
isStarted = true
- helperPackageValidation.objectWillChange
+ powerHelperPackageValidation.objectWillChange
.sink { [weak self] in self?.objectWillChange.send() }
.store(in: &cancellables)
@@ -208,8 +208,8 @@ final class KeepAliveController: ObservableObject {
isStarted = false
cancellables.removeAll()
cancelRetryTask()
- cancelHelperRegistrationTask()
- helperPackageValidation.cancel()
+ cancelPowerHelperRegistrationTask()
+ powerHelperPackageValidation.cancel()
autoResetWakeScheduler.stop()
cancelExternalObservation()
runningTaskIDs.removeAll()
@@ -235,12 +235,12 @@ final class KeepAliveController: ObservableObject {
isPreparingForTermination = true
cancelRetryTask()
- cancelHelperRegistrationTask()
+ cancelPowerHelperRegistrationTask()
cancelExternalObservation()
let wakeScheduleReleased = await autoResetWakeScheduler.prepareForTermination(
- helperSupportsWakeScheduling: isHelperReadyForAutoResetWake
+ powerHelperSupportsWakeScheduling: isPowerHelperReadyForAutoResetWake
)
- let sleepLeaseReleased = await releaseHelperLeaseIfNeeded(trigger: .termination)
+ let sleepLeaseReleased = await releasePowerHelperLeaseIfNeeded(trigger: .termination)
let success = wakeScheduleReleased && sleepLeaseReleased
guard !success else {
return true
@@ -261,15 +261,15 @@ final class KeepAliveController: ObservableObject {
private func refreshRegistrationAndSleepState(refreshPackage: Bool = true) {
if isStarted, refreshPackage {
- helperPackageValidation.refresh()
+ powerHelperPackageValidation.refresh()
return
}
- guard helperRegistrationTask == nil else {
+ guard powerHelperRegistrationTask == nil else {
reconcileSleepState(trigger: .statusRefresh)
return
}
- ensureHelperRegistration()
+ ensurePowerHelperRegistration()
}
// MARK: - 设置入口
@@ -287,7 +287,7 @@ final class KeepAliveController: ObservableObject {
operationErrorMessage = nil
if enabled {
- ensureHelperRegistration()
+ ensurePowerHelperRegistration()
} else {
durationLimiter.reset()
}
@@ -500,51 +500,51 @@ final class KeepAliveController: ObservableObject {
durationLimiter.restart(isPreventingSleep: isPreventingSleep)
}
- // MARK: - helper 注册
+ // MARK: - Power Helper 注册
- private func ensureHelperRegistration() {
- guard helperRegistrationTask == nil else { return }
- guard let fingerprint = helperPackageValidation.fingerprint else {
- if helperPackageValidation.issue == nil {
- helperPackageValidation.refresh()
+ private func ensurePowerHelperRegistration() {
+ guard powerHelperRegistrationTask == nil else { return }
+ guard let fingerprint = powerHelperPackageValidation.fingerprint else {
+ if powerHelperPackageValidation.issue == nil {
+ powerHelperPackageValidation.refresh()
}
return
}
- let lifecycleGeneration = helperLifecycleGeneration
- helperRegistrationTask = Task { @MainActor [weak self] in
+ let lifecycleGeneration = powerHelperLifecycleGeneration
+ powerHelperRegistrationTask = Task { @MainActor [weak self] in
guard let self else { return }
defer {
- if lifecycleGeneration == helperLifecycleGeneration {
- helperRegistrationTask = nil
+ if lifecycleGeneration == powerHelperLifecycleGeneration {
+ powerHelperRegistrationTask = nil
}
}
- guard await refreshHelperStatus(), isStarted, !Task.isCancelled else { return }
- switch helperStatus {
+ guard await refreshPowerHelperStatus(), isStarted, !Task.isCancelled else { return }
+ switch powerHelperStatus {
case .enabled, .requiresApproval:
- if HelperConfiguration.registrationNeedsRefresh(defaults: defaults, fingerprint: fingerprint) {
- await refreshRegisteredHelper()
- } else if helperStatus == .enabled,
- let updateIdentifier = HelperConfiguration.pendingUpdateIdentifier(
+ if PowerHelperConfiguration.registrationNeedsRefresh(defaults: defaults, fingerprint: fingerprint) {
+ await refreshRegisteredPowerHelper()
+ } else if powerHelperStatus == .enabled,
+ let updateIdentifier = PowerHelperConfiguration.pendingUpdateIdentifier(
defaults: defaults, fingerprint: fingerprint
) {
- await completePendingHelperUpdate(updateIdentifier)
+ await completePendingPowerHelperUpdate(updateIdentifier)
}
case .notRegistered, .notFound:
if isEnabled || isAutoResetRequested {
- AppLog.keepAlive.notice("Helper 注册开始")
+ AppLog.keepAlive.notice("Power Helper 注册开始")
do {
- _ = try await helperManager.perform(.register)
+ _ = try await powerHelperManager.perform(.register)
} catch is CancellationError {
return
} catch {
- AppLog.keepAlive.error("Helper 注册失败: detail=\(error.localizedDescription, privacy: .public)")
+ AppLog.keepAlive.error("Power Helper 注册失败: detail=\(error.localizedDescription, privacy: .public)")
registrationErrorMessage = KeepAliveLocalizedMessage.registrationFailed
}
- guard await refreshHelperStatus(), !Task.isCancelled else { return }
- HelperConfiguration.recordRegistration(defaults: defaults, status: helperStatus, fingerprint: fingerprint)
- if helperStatus == .enabled,
- let updateIdentifier = HelperConfiguration.pendingUpdateIdentifier(defaults: defaults, fingerprint: fingerprint) {
- await completePendingHelperUpdate(updateIdentifier)
+ guard await refreshPowerHelperStatus(), !Task.isCancelled else { return }
+ PowerHelperConfiguration.recordRegistration(defaults: defaults, status: powerHelperStatus, fingerprint: fingerprint)
+ if powerHelperStatus == .enabled,
+ let updateIdentifier = PowerHelperConfiguration.pendingUpdateIdentifier(defaults: defaults, fingerprint: fingerprint) {
+ await completePendingPowerHelperUpdate(updateIdentifier)
}
}
}
@@ -554,35 +554,35 @@ final class KeepAliveController: ObservableObject {
}
}
- private func refreshRegisteredHelper() async {
- let requiresSleepReset = helperStatus == .enabled
- guard let fingerprint = helperPackageValidation.fingerprint else {
+ private func refreshRegisteredPowerHelper() async {
+ let requiresSleepReset = powerHelperStatus == .enabled
+ guard let fingerprint = powerHelperPackageValidation.fingerprint else {
return
}
- guard autoResetWakeScheduler.beginHelperInterruptionPreparation() else {
+ guard autoResetWakeScheduler.beginPowerHelperInterruptionPreparation() else {
return
}
- let updateIdentifier = HelperConfiguration.beginUpdate(
+ let updateIdentifier = PowerHelperConfiguration.beginUpdate(
defaults: defaults,
requiresSleepReset: requiresSleepReset,
fingerprint: fingerprint
)
- assign(true, to: \.isRefreshingHelper)
+ assign(true, to: \.isRefreshingPowerHelper)
cancelRetryTask()
cancelExternalObservation()
invalidateConnection()
- // 刷新期间已冻结新接管, 旧 helper 由 unregister 终止
+ // 刷新期间已冻结新接管, 旧 Power Helper 由 unregister 终止
registrationErrorMessage = nil
operationErrorMessage = nil
do {
defer {
- autoResetWakeScheduler.resumeAfterHelperInterruption()
+ autoResetWakeScheduler.resumeAfterPowerHelperInterruption()
}
let updateError: Error?
do {
- try await replaceRegisteredHelper()
+ try await replaceRegisteredPowerHelper()
updateError = nil
} catch is CancellationError {
return
@@ -595,41 +595,41 @@ final class KeepAliveController: ObservableObject {
return
}
- guard await refreshHelperStatus() else { return }
- var helperWasUpdated = false
+ guard await refreshPowerHelperStatus() else { return }
+ var powerHelperWasUpdated = false
if updateError == nil,
- helperStatus.isRegisteredOrAwaitingApproval {
- HelperConfiguration.recordRegistration(
+ powerHelperStatus.isRegisteredOrAwaitingApproval {
+ PowerHelperConfiguration.recordRegistration(
defaults: defaults,
- status: helperStatus,
+ status: powerHelperStatus,
fingerprint: fingerprint
)
if !requiresSleepReset {
- helperWasUpdated = true
- } else if helperStatus == .enabled {
- helperWasUpdated = await completeHelperUpdate(updateIdentifier)
+ powerHelperWasUpdated = true
+ } else if powerHelperStatus == .enabled {
+ powerHelperWasUpdated = await completePowerHelperUpdate(updateIdentifier)
} else {
// 从 enabled 更新后若需要系统批准, 睡眠状态核对会在批准后继续
- helperWasUpdated = true
+ powerHelperWasUpdated = true
}
}
- if !helperWasUpdated {
+ if !powerHelperWasUpdated {
let detail = updateError?.localizedDescription ?? "readinessFailed"
AppLog.keepAlive.error(
- "Helper 注册更新失败: detail=\(detail, privacy: .public)"
+ "Power Helper 注册更新失败: detail=\(detail, privacy: .public)"
)
registrationErrorMessage = KeepAliveLocalizedMessage.updateFailed
}
- assign(!helperWasUpdated && helperStatus == .enabled, to: \.isRefreshingHelper)
- reconcileSleepState(trigger: .helperRegistered, force: true)
+ assign(!powerHelperWasUpdated && powerHelperStatus == .enabled, to: \.isRefreshingPowerHelper)
+ reconcileSleepState(trigger: .powerHelperRegistered, force: true)
reconcileAutoResetWakeSchedule()
}
}
/// @Published 在 willSet 无条件发信号, 不比较新旧值
- /// refreshHelperStatus 每次 App 激活跑, releaseSleepPrevention 每条活动快照都会经过
+ /// refreshPowerHelperStatus 每次 App 激活跑, releaseSleepPrevention 每条活动快照都会经过
/// 同值赋值会让菜单面板和设置页反复空转, 所以反复求值路径上的写入都走这里
/// 用户动作与一次性的操作结果本来就不会重复, 直接赋值即可
private func assign<Value: Equatable>(
@@ -643,37 +643,37 @@ final class KeepAliveController: ObservableObject {
}
@discardableResult
- private func refreshHelperStatus() async -> Bool {
+ private func refreshPowerHelperStatus() async -> Bool {
let status: SMAppService.Status
do {
- status = try await helperManager.perform(.status)
+ status = try await powerHelperManager.perform(.status)
try Task.checkCancellation()
} catch is CancellationError {
return false
} catch {
- AppLog.keepAlive.error("Helper 注册状态查询失败: detail=\(error.localizedDescription, privacy: .public)")
+ AppLog.keepAlive.error("Power Helper 注册状态查询失败: detail=\(error.localizedDescription, privacy: .public)")
registrationErrorMessage = KeepAliveLocalizedMessage.connectionFailed
- isHelperStatusAvailable = false
+ isPowerHelperStatusAvailable = false
cancelRetryTask()
invalidateConnection()
reconcileSleepState(trigger: .statusRefresh)
reconcileAutoResetWakeSchedule()
return false
}
- isHelperStatusAvailable = true
- let previousStatus = helperStatus
- assign(HelperStatus(status), to: \.helperStatus)
+ isPowerHelperStatusAvailable = true
+ let previousStatus = powerHelperStatus
+ assign(PowerHelperStatus(status), to: \.powerHelperStatus)
// 每次 App 激活都会跑, 只记真正的迁移, 否则日志会被无变化的求值淹没
// 取局部量再插值: Logger 的插值是 autoclosure, 直接写属性会被要求显式 self, 与 --self remove 冲突
- let currentStatus = helperStatus
+ let currentStatus = powerHelperStatus
if currentStatus != previousStatus {
let details = LogFields.joined(
"from=\(String(describing: previousStatus))",
"to=\(String(describing: currentStatus))"
)
- AppLog.keepAlive.notice("Helper 注册状态变化: \(details, privacy: .public)")
+ AppLog.keepAlive.notice("Power Helper 注册状态变化: \(details, privacy: .public)")
}
- if helperStatus == .enabled {
+ if powerHelperStatus == .enabled {
// 注册已正常, 只撤回注册类抱怨
// 操作类结果 (例如重试耗尽) 必须留到下一次操作有结论为止
assign(nil, to: \.registrationErrorMessage)
@@ -682,7 +682,7 @@ final class KeepAliveController: ObservableObject {
cancelRetryTask()
invalidateConnection()
assign(nil, to: \.operationErrorMessage)
- if helperStatus != .requiresApproval {
+ if powerHelperStatus != .requiresApproval {
durationLimiter.reset()
}
publishDerivedState(blockReason: sleepBlockReason)
@@ -702,8 +702,8 @@ final class KeepAliveController: ObservableObject {
reconcileDisplayAwake()
logSleepConditionsIfChanged(blockReason: blockReason, trigger: trigger)
- // Helper 未授权或刷新期间不发普通租约请求, 未确认的租约留待恢复后清理
- guard helperStatus == .enabled, !isRefreshingHelper else {
+ // Power Helper 未授权或刷新期间不发普通租约请求, 未确认的租约留待恢复后清理
+ guard powerHelperStatus == .enabled, !isRefreshingPowerHelper else {
cancelRetryTask()
releaseSleepPrevention()
return
@@ -711,7 +711,7 @@ final class KeepAliveController: ObservableObject {
guard wantsSleepDisabled else {
cancelRetryTask()
- if mayHaveHelperLease || isPreventingSleep {
+ if mayHavePowerHelperLease || isPreventingSleep {
applySleepPreventionRequested(false)
} else {
releaseSleepPrevention()
@@ -743,7 +743,7 @@ final class KeepAliveController: ObservableObject {
}
/// 从阻断原因计算 UI 状态, 只在结论变化时发布
- /// 避免任务或 helper 状态频繁变化时重复刷新设置页
+ /// 避免任务或 Power Helper 状态频繁变化时重复刷新设置页
private func publishDerivedState(blockReason: SleepBlockReason?) {
assign(blockReason == .lowBattery, to: \.isLowBatteryBlocking)
assign(Self.allowsOptions(blockReason), to: \.canShowOptions)
@@ -768,9 +768,9 @@ final class KeepAliveController: ObservableObject {
/// 因任务, 电量或时长暂停防睡眠时, 仍允许修改设置
private static func allowsOptions(_ blockReason: SleepBlockReason?) -> Bool {
switch blockReason {
- case .notStarted, .userOff, .helperUnavailable, .terminating:
+ case .notStarted, .userOff, .powerHelperUnavailable, .terminating:
false
- case nil, .noTasks, .helperRefreshing, .lowBattery, .limitReached:
+ case nil, .noTasks, .powerHelperRefreshing, .lowBattery, .limitReached:
true
}
}
@@ -784,8 +784,8 @@ final class KeepAliveController: ObservableObject {
blockReason: blockReason,
enabled: isEnabled,
tasks: hasKeepAliveTasks,
- helper: helperStatus,
- refreshing: isRefreshingHelper,
+ powerHelper: powerHelperStatus,
+ refreshing: isRefreshingPowerHelper,
battery: isLowBatteryActive,
limited: hasReachedMaximumDuration
)
@@ -797,13 +797,13 @@ final class KeepAliveController: ObservableObject {
lastLoggedSleepConditions = conditions
let triggerName = trigger.rawValue
- let helperName = String(describing: conditions.helper)
+ let powerHelperName = String(describing: conditions.powerHelper)
let details = LogFields.joined(
"trigger=\(triggerName)",
"want=\(blockReason == nil ? 1 : 0)",
"enabled=\(conditions.enabled ? 1 : 0)",
"tasks=\(conditions.tasks ? 1 : 0)",
- "helper=\(helperName)",
+ "powerHelper=\(powerHelperName)",
"refreshing=\(conditions.refreshing ? 1 : 0)",
"battery=\(conditions.battery ? 1 : 0)",
"limited=\(conditions.limited ? 1 : 0)"
@@ -841,13 +841,13 @@ final class KeepAliveController: ObservableObject {
}
}
- helperStatusMonitor.cancelRequest()
+ powerHelperStatusMonitor.cancelRequest()
completePendingRequest(success: false)
let connection = connection ?? makeConnection()
appliedSleepPreventionRequested = requested
if requested {
- // 发出后就要按可能被 helper 接收处理, 不能等回复才记这笔租约
- mayHaveHelperLease = true
+ // 发出后就要按可能被 Power Helper 接收处理, 不能等回复才记这笔租约
+ mayHavePowerHelperLease = true
}
requestInFlight = true
requestGeneration &+= 1
@@ -858,7 +858,7 @@ final class KeepAliveController: ObservableObject {
"op=\(requested ? "acquire" : "release")",
"generation=\(generation)"
)
- AppLog.keepAlive.notice("Helper XPC 请求已发送: \(details, privacy: .public)")
+ AppLog.keepAlive.notice("Power Helper XPC 请求已发送: \(details, privacy: .public)")
}
scheduleRequestTimeout(for: requested, generation: generation)
@@ -870,9 +870,9 @@ final class KeepAliveController: ObservableObject {
self.handleConnectionFailure(error)
}
}
- guard let helper = connection.remoteObjectProxyWithErrorHandler(errorHandler)
- as? CodexBarHelperProtocol else {
- handleConnectionFailure(KeepAliveError.invalidHelperProxy)
+ guard let powerHelper = connection.remoteObjectProxyWithErrorHandler(errorHandler)
+ as? CodexBarPowerHelperProtocol else {
+ handleConnectionFailure(KeepAliveError.invalidPowerHelperProxy)
return
}
@@ -888,9 +888,9 @@ final class KeepAliveController: ObservableObject {
)
}
}
- helper.setSleepPreventionRequested(
+ powerHelper.setSleepPreventionRequested(
requested,
- clientSessionID: helperClientSessionID,
+ clientSessionID: powerHelperClientSessionID,
generation: generation,
reply: reply
)
@@ -916,7 +916,7 @@ final class KeepAliveController: ObservableObject {
"result=\(replyResult)",
"exit=\(exitCode)"
)
- AppLog.keepAlive.notice("Helper XPC 回复已收到: \(details, privacy: .public)")
+ AppLog.keepAlive.notice("Power Helper XPC 回复已收到: \(details, privacy: .public)")
}
guard exitCode == 0 else {
handleSleepPreventionFailure(
@@ -973,7 +973,7 @@ final class KeepAliveController: ObservableObject {
"detail=\(detail)"
)
AppLog.keepAlive.error("系统睡眠切换失败: \(details, privacy: .public)")
- handleHelperFailure(KeepAliveLocalizedMessage.toggleSleepFailed, retrying: requested)
+ handlePowerHelperFailure(KeepAliveLocalizedMessage.toggleSleepFailed, retrying: requested)
}
private func updateSleepPreventionSource(
@@ -984,7 +984,7 @@ final class KeepAliveController: ObservableObject {
assign(source, to: \.sleepPreventionSource)
reconcileExternalObservation()
} else {
- mayHaveHelperLease = false
+ mayHavePowerHelperLease = false
cancelExternalObservation()
assign(.none, to: \.sleepPreventionSource)
}
@@ -1058,55 +1058,55 @@ final class KeepAliveController: ObservableObject {
completion?(success)
}
- private func fetchHelperRuntimeStatus() async -> HelperRuntimeStatus? {
- guard !requestInFlight, !helperStatusMonitor.isRequestInFlight else {
+ private func fetchPowerHelperRuntimeStatus() async -> PowerHelperRuntimeStatus? {
+ guard !requestInFlight, !powerHelperStatusMonitor.isRequestInFlight else {
return nil
}
let connection = connection ?? makeConnection()
- return await helperStatusMonitor.fetch(
+ return await powerHelperStatusMonitor.fetch(
connection: connection,
- timeout: HelperConfiguration.requestTimeout,
+ timeout: PowerHelperConfiguration.requestTimeout,
onConnectionFailure: { [weak self] error in
self?.handleConnectionFailure(error)
},
onTimeout: { [weak self] in
- self?.handleHelperStatusTimeout()
+ self?.handlePowerHelperStatusTimeout()
}
)
}
- private func resetSleepAfterHelperUpdate(_ updateIdentifier: String) async -> Bool {
- guard !requestInFlight, !helperStatusMonitor.isRequestInFlight else {
+ private func resetSleepAfterPowerHelperUpdate(_ updateIdentifier: String) async -> Bool {
+ guard !requestInFlight, !powerHelperStatusMonitor.isRequestInFlight else {
return false
}
let connection = connection ?? makeConnection()
- return await helperStatusMonitor.resetSleepAfterUpdate(
+ return await powerHelperStatusMonitor.resetSleepAfterUpdate(
connection: connection,
updateIdentifier: updateIdentifier,
- timeout: HelperConfiguration.requestTimeout,
+ timeout: PowerHelperConfiguration.requestTimeout,
onConnectionFailure: { [weak self] error in
self?.handleConnectionFailure(error)
},
onTimeout: { [weak self] in
- self?.handleHelperStatusTimeout()
+ self?.handlePowerHelperStatusTimeout()
}
)
}
- private func handleHelperStatusTimeout() {
- handleHelperFailure(
+ private func handlePowerHelperStatusTimeout() {
+ handlePowerHelperFailure(
KeepAliveLocalizedMessage.noResponse,
retrying: isPreventingSleep ? shouldDisableSleep : nil
)
}
- private func releaseHelperLeaseIfNeeded(trigger: LogTrigger) async -> Bool {
+ private func releasePowerHelperLeaseIfNeeded(trigger: LogTrigger) async -> Bool {
let blockReason = sleepBlockReason
publishDerivedState(blockReason: blockReason)
reconcileDisplayAwake()
logSleepConditionsIfChanged(blockReason: blockReason, trigger: trigger)
- guard mayHaveHelperLease || isPreventingSleep else {
+ guard mayHavePowerHelperLease || isPreventingSleep else {
releaseSleepPrevention()
return true
}
@@ -1122,18 +1122,18 @@ final class KeepAliveController: ObservableObject {
private func makeConnection() -> NSXPCConnection {
let connection = NSXPCConnection(
- machServiceName: CodexBarHelperIPC.machServiceName,
+ machServiceName: CodexBarPowerHelperIPC.serviceIdentifier,
options: .privileged
)
connection.remoteObjectInterface = NSXPCInterface(
- with: CodexBarHelperProtocol.self
+ with: CodexBarPowerHelperProtocol.self
)
connection.invalidationHandler = { [weak self, weak connection] in
Task { @MainActor in
guard let self, let connection, self.connection === connection else {
return
}
- self.handleHelperFailure(nil, retrying: self.requestInFlight || self.isPreventingSleep ? self.shouldDisableSleep : nil)
+ self.handlePowerHelperFailure(nil, retrying: self.requestInFlight || self.isPreventingSleep ? self.shouldDisableSleep : nil)
}
}
connection.interruptionHandler = { [weak self, weak connection] in
@@ -1146,32 +1146,32 @@ final class KeepAliveController: ObservableObject {
}
connection.resume()
self.connection = connection
- AppLog.keepAlive.notice("Helper XPC 已连接")
+ AppLog.keepAlive.notice("Power Helper XPC 已连接")
return connection
}
private func handleConnectionFailure(_ error: Error) {
- AppLog.keepAlive.error("Helper XPC 连接失败: detail=\(error.localizedDescription, privacy: .public)")
- handleHelperFailure(
+ AppLog.keepAlive.error("Power Helper XPC 连接失败: detail=\(error.localizedDescription, privacy: .public)")
+ handlePowerHelperFailure(
KeepAliveLocalizedMessage.connectionFailed,
retrying: requestInFlight || isPreventingSleep ? shouldDisableSleep : nil
)
}
/// 断连和超时统一先复核授权, retrying 为 nil 时只收敛状态, 不重试租约
- private func handleHelperFailure(_ message: String?, retrying requested: Bool?) {
+ private func handlePowerHelperFailure(_ message: String?, retrying requested: Bool?) {
invalidateConnection()
- guard helperFailureTask == nil else { return }
- let lifecycleGeneration = helperLifecycleGeneration
- helperFailureTask = Task { @MainActor [weak self] in
+ guard powerHelperFailureTask == nil else { return }
+ let lifecycleGeneration = powerHelperLifecycleGeneration
+ powerHelperFailureTask = Task { @MainActor [weak self] in
guard let self else { return }
defer {
- if lifecycleGeneration == helperLifecycleGeneration {
- helperFailureTask = nil
+ if lifecycleGeneration == powerHelperLifecycleGeneration {
+ powerHelperFailureTask = nil
}
}
- guard await refreshHelperStatus(), isStarted, !Task.isCancelled,
- helperStatus == .enabled else { return }
+ guard await refreshPowerHelperStatus(), isStarted, !Task.isCancelled,
+ powerHelperStatus == .enabled else { return }
if let message {
operationErrorMessage = message
}
@@ -1181,26 +1181,26 @@ final class KeepAliveController: ObservableObject {
}
}
- /// helper 起不来时 XPC 方法既不回复也不触发 errorHandler, 请求就那么挂着
+ /// Power Helper 起不来时 XPC 方法既不回复也不触发 errorHandler, 请求就那么挂着
/// 没有这道超时, 界面会显示防睡眠开着而实际没生效, 日志里只剩一条没有配对回复的请求已发送
private func scheduleRequestTimeout(for requested: Bool, generation: UInt64) {
requestTimeoutTask?.cancel()
requestTimeoutTask = Task { @MainActor [weak self] in
- try? await Task.sleep(for: HelperConfiguration.requestTimeout)
+ try? await Task.sleep(for: PowerHelperConfiguration.requestTimeout)
// 认状态而不是认取消位: 每条取消路径都同时推进了 generation 或清了 in-flight,
// 认状态就不必依赖将来每个新路径都记得 cancel
guard let self, generation == requestGeneration, requestInFlight else {
return
}
- let timeout = LogDuration.seconds(HelperConfiguration.requestTimeout)
+ let timeout = LogDuration.seconds(PowerHelperConfiguration.requestTimeout)
let details = LogFields.joined(
"op=\(requested ? "acquire" : "release")",
"generation=\(generation)",
"timeout=\(timeout)"
)
- AppLog.keepAlive.error("Helper XPC 请求超时: \(details, privacy: .public)")
- handleHelperFailure(KeepAliveLocalizedMessage.noResponse, retrying: requested)
+ AppLog.keepAlive.error("Power Helper XPC 请求超时: \(details, privacy: .public)")
+ handlePowerHelperFailure(KeepAliveLocalizedMessage.noResponse, retrying: requested)
}
}
@@ -1212,7 +1212,7 @@ final class KeepAliveController: ObservableObject {
private func invalidateConnection() {
cancelRequestTimeout()
cancelExternalObservation()
- helperStatusMonitor.cancelRequest()
+ powerHelperStatusMonitor.cancelRequest()
requestGeneration &+= 1
let connection = connection
self.connection = nil
@@ -1222,10 +1222,10 @@ final class KeepAliveController: ObservableObject {
completePendingRequest(success: false)
// 无连接时也会走到这里, 只记真的断掉了一条, 避免空转刷屏
if connection != nil {
- let mayHaveLease = mayHaveHelperLease ? 1 : 0
- AppLog.keepAlive.notice("Helper XPC 已断开: mayHaveLease=\(mayHaveLease)")
+ let mayHaveLease = mayHavePowerHelperLease ? 1 : 0
+ AppLog.keepAlive.notice("Power Helper XPC 已断开: mayHaveLease=\(mayHaveLease)")
}
- // 断连不能清 mayHaveHelperLease, 请求可能已在 helper 执行只是回复丢了
+ // 断连不能清 mayHavePowerHelperLease, 请求可能已在 Power Helper 执行只是回复丢了
appliedSleepPreventionRequested = nil
requestInFlight = false
releaseSleepPrevention()
@@ -1245,7 +1245,7 @@ final class KeepAliveController: ObservableObject {
durationLimiter.pause()
}
- /// pmset 轮询统一由 helper 执行, App 这里只读取缓存状态来刷新来源显示
+ /// pmset 轮询统一由 Power Helper 执行, App 这里只读取缓存状态来刷新来源显示
private func reconcileExternalObservation() {
guard sleepPreventionSource == .external,
isPreventingSleep,
@@ -1253,8 +1253,8 @@ final class KeepAliveController: ObservableObject {
cancelExternalObservation()
return
}
- helperStatusMonitor.startObservation(
- interval: HelperConfiguration.externalObservationInterval
+ powerHelperStatusMonitor.startObservation(
+ interval: PowerHelperConfiguration.externalObservationInterval
) { [weak self] in
guard let self,
sleepPreventionSource == .external,
@@ -1264,14 +1264,14 @@ final class KeepAliveController: ObservableObject {
return
}
guard !requestInFlight,
- let status = await fetchHelperRuntimeStatus() else {
+ let status = await fetchPowerHelperRuntimeStatus() else {
return
}
handleExternalObservation(status)
}
}
- private func handleExternalObservation(_ status: HelperRuntimeStatus) {
+ private func handleExternalObservation(_ status: PowerHelperRuntimeStatus) {
guard sleepPreventionSource == .external,
isPreventingSleep,
shouldDisableSleep else {
@@ -1296,7 +1296,7 @@ final class KeepAliveController: ObservableObject {
}
private func cancelExternalObservation() {
- helperStatusMonitor.cancelObservation()
+ powerHelperStatusMonitor.cancelObservation()
}
// MARK: - 屏幕常亮
@@ -1340,36 +1340,36 @@ final class KeepAliveController: ObservableObject {
retryAttempt = 0
}
- private func cancelHelperRegistrationTask() {
- helperLifecycleGeneration &+= 1
- helperFailureTask?.cancel()
- helperFailureTask = nil
- helperRegistrationTask?.cancel()
- helperRegistrationTask = nil
- assign(false, to: \.isRefreshingHelper)
+ private func cancelPowerHelperRegistrationTask() {
+ powerHelperLifecycleGeneration &+= 1
+ powerHelperFailureTask?.cancel()
+ powerHelperFailureTask = nil
+ powerHelperRegistrationTask?.cancel()
+ powerHelperRegistrationTask = nil
+ assign(false, to: \.isRefreshingPowerHelper)
reconcileAutoResetWakeSchedule()
- autoResetWakeScheduler.resumeAfterHelperInterruption()
+ autoResetWakeScheduler.resumeAfterPowerHelperInterruption()
}
private func scheduleRetryIfNeeded(for requested: Bool) {
guard isStarted,
- helperStatus == .enabled,
+ powerHelperStatus == .enabled,
requested == shouldDisableSleep,
retryTask == nil else {
return
}
// 每次重试都会重建特权连接并以 root 拉起 pmset
- // 限制重试次数, 避免 helper 持续失败时反复拉起特权进程
- guard retryAttempt < HelperConfiguration.sleepToggleRetryDelays.count else {
+ // 限制重试次数, 避免 Power Helper 持续失败时反复拉起特权进程
+ guard retryAttempt < PowerHelperConfiguration.sleepToggleRetryDelays.count else {
AppLog.keepAlive.error(
- "KeepAlive 切换重试已放弃: attempts=\(HelperConfiguration.sleepToggleRetryDelays.count)"
+ "KeepAlive 切换重试已放弃: attempts=\(PowerHelperConfiguration.sleepToggleRetryDelays.count)"
)
operationErrorMessage = KeepAliveLocalizedMessage.retryLimitReached
return
}
- let delay = HelperConfiguration.sleepToggleRetryDelays[retryAttempt]
+ let delay = PowerHelperConfiguration.sleepToggleRetryDelays[retryAttempt]
retryAttempt += 1
let attempt = retryAttempt
let wait = LogDuration.seconds(delay)
@@ -1385,7 +1385,7 @@ final class KeepAliveController: ObservableObject {
guard !Task.isCancelled, let self else {
return
}
- guard await refreshHelperStatus(), isStarted, !Task.isCancelled, helperStatus == .enabled else {
+ guard await refreshPowerHelperStatus(), isStarted, !Task.isCancelled, powerHelperStatus == .enabled else {
return
}
retryTask = nil
@@ -1423,15 +1423,15 @@ final class KeepAliveController: ObservableObject {
if !isEnabled {
return .userOff
}
- // 先检查依赖, 避免任务恢复前以 noTasks 提前放出未授权 Helper 的设置入口
- if !isHelperStatusAvailable || helperStatus != .enabled {
- return .helperUnavailable
+ // 先检查依赖, 避免任务恢复前以 noTasks 提前放出未授权 Power Helper 的设置入口
+ if !isPowerHelperStatusAvailable || powerHelperStatus != .enabled {
+ return .powerHelperUnavailable
}
if !hasKeepAliveTasks {
return .noTasks
}
- if isRefreshingHelper {
- return .helperRefreshing
+ if isRefreshingPowerHelper {
+ return .powerHelperRefreshing
}
if isLowBatteryActive {
return .lowBattery
@@ -1453,17 +1453,17 @@ final class KeepAliveController: ObservableObject {
}
extension KeepAliveController {
- private func replaceRegisteredHelper() async throws {
+ private func replaceRegisteredPowerHelper() async throws {
try Task.checkCancellation()
- guard await autoResetWakeScheduler.cancelBeforeHelperInterruption() else {
+ guard await autoResetWakeScheduler.cancelBeforePowerHelperInterruption() else {
throw KeepAliveError.wakeScheduleCancellationFailed
}
reconcileAutoResetWakeSchedule()
try Task.checkCancellation()
- _ = try await helperManager.perform(.unregister)
- mayHaveHelperLease = false
+ _ = try await powerHelperManager.perform(.unregister)
+ mayHavePowerHelperLease = false
try Task.checkCancellation()
- try await HelperConfiguration.registerRefreshedHelper(helperManager)
+ try await PowerHelperConfiguration.registerRefreshedPowerHelper(powerHelperManager)
}
func setAutoResetRequested(_ requested: Bool) {
@@ -1477,7 +1477,7 @@ extension KeepAliveController {
isAutoResetRequested = requested
autoResetWakeScheduler.setRequested(requested)
if requested, isStarted {
- ensureHelperRegistration()
+ ensurePowerHelperRegistration()
}
reconcileAutoResetWakeSchedule()
}
@@ -1486,43 +1486,43 @@ extension KeepAliveController {
autoResetWakeScheduler.setWakeDate(date)
}
- private var isHelperReadyForAutoResetWake: Bool {
- guard isHelperStatusAvailable, helperStatus == .enabled,
- !isRefreshingHelper,
- let fingerprint = helperPackageValidation.fingerprint,
- !HelperConfiguration.registrationNeedsRefresh(defaults: defaults, fingerprint: fingerprint) else {
+ private var isPowerHelperReadyForAutoResetWake: Bool {
+ guard isPowerHelperStatusAvailable, powerHelperStatus == .enabled,
+ !isRefreshingPowerHelper,
+ let fingerprint = powerHelperPackageValidation.fingerprint,
+ !PowerHelperConfiguration.registrationNeedsRefresh(defaults: defaults, fingerprint: fingerprint) else {
return false
}
- return HelperConfiguration.pendingUpdateIdentifier(defaults: defaults, fingerprint: fingerprint) == nil
+ return PowerHelperConfiguration.pendingUpdateIdentifier(defaults: defaults, fingerprint: fingerprint) == nil
}
private func reconcileAutoResetWakeSchedule() {
- autoResetWakeScheduler.setHelperReady(
- isStarted && isHelperReadyForAutoResetWake
+ autoResetWakeScheduler.setPowerHelperReady(
+ isStarted && isPowerHelperReadyForAutoResetWake
)
}
}
private extension KeepAliveController {
- func completePendingHelperUpdate(_ updateIdentifier: String) async {
- assign(true, to: \.isRefreshingHelper)
+ func completePendingPowerHelperUpdate(_ updateIdentifier: String) async {
+ assign(true, to: \.isRefreshingPowerHelper)
reconcileAutoResetWakeSchedule()
cancelRetryTask()
cancelExternalObservation()
registrationErrorMessage = nil
operationErrorMessage = nil
- let succeeded = await completeHelperUpdate(updateIdentifier)
+ let succeeded = await completePowerHelperUpdate(updateIdentifier)
guard isStarted, !Task.isCancelled else { return }
if !succeeded {
registrationErrorMessage = KeepAliveLocalizedMessage.updateFailed
}
- assign(!succeeded && helperStatus == .enabled, to: \.isRefreshingHelper)
- reconcileSleepState(trigger: .helperRegistered, force: true)
+ assign(!succeeded && powerHelperStatus == .enabled, to: \.isRefreshingPowerHelper)
+ reconcileSleepState(trigger: .powerHelperRegistered, force: true)
reconcileAutoResetWakeSchedule()
}
- func completeHelperUpdate(_ updateIdentifier: String) async -> Bool {
- for delay in HelperConfiguration.updateCompletionRetryDelays {
+ func completePowerHelperUpdate(_ updateIdentifier: String) async -> Bool {
+ for delay in PowerHelperConfiguration.updateCompletionRetryDelays {
if delay > .zero {
try? await Task.sleep(for: delay)
}
@@ -1530,15 +1530,15 @@ private extension KeepAliveController {
return false
}
- guard await refreshHelperStatus(), helperStatus == .enabled else {
+ guard await refreshPowerHelperStatus(), powerHelperStatus == .enabled else {
continue
}
- if await resetSleepAfterHelperUpdate(updateIdentifier) {
- HelperConfiguration.completeUpdate(
+ if await resetSleepAfterPowerHelperUpdate(updateIdentifier) {
+ PowerHelperConfiguration.completeUpdate(
updateIdentifier,
defaults: defaults
)
- mayHaveHelperLease = false
+ mayHavePowerHelperLease = false
appliedSleepPreventionRequested = nil
operationErrorMessage = nil
return true
diff --git a/CodexBar/Services/KeepAlive/KeepAliveDurationLimiter.swift b/CodexBar/Services/KeepAlive/KeepAliveDurationLimiter.swift
index 7b851d6..d7e35c1 100644
--- a/CodexBar/Services/KeepAlive/KeepAliveDurationLimiter.swift
+++ b/CodexBar/Services/KeepAlive/KeepAliveDurationLimiter.swift
@@ -79,7 +79,7 @@ final class KeepAliveDurationLimiter: ObservableObject {
}
/// 防睡眠解除时收表, 把这一段并进累计值
- /// 收表之后的时间一律不算: 机器睡着, 低电量拦着, helper 断开都不该占用户的上限
+ /// 收表之后的时间一律不算: 机器睡着, 低电量拦着, Power Helper 断开都不该占用户的上限
func pause() {
guard let runningSince else {
return
diff --git a/CodexBar/Services/KeepAlive/KeepAliveModels.swift b/CodexBar/Services/KeepAlive/KeepAliveModels.swift
index 7793173..6cace4b 100644
--- a/CodexBar/Services/KeepAlive/KeepAliveModels.swift
+++ b/CodexBar/Services/KeepAlive/KeepAliveModels.swift
@@ -63,7 +63,7 @@ extension KeepAliveController {
}
}
- enum HelperStatus: Equatable {
+ enum PowerHelperStatus: Equatable {
case notRegistered
case enabled
case requiresApproval
@@ -89,13 +89,13 @@ extension KeepAliveController {
}
}
- enum HelperInstallationStatus: Equatable {
+ enum PowerHelperInstallationStatus: Equatable {
case notInstalled
case authorized
case requiresApproval
case unavailable(String)
- init(registration: HelperStatus, packageIssue: HelperPackageIssue?, registrationError: String?) {
+ init(registration: PowerHelperStatus, packageIssue: PowerHelperPackageIssue?, registrationError: String?) {
if let packageIssue {
self = .unavailable(packageIssue.message)
return
@@ -117,8 +117,8 @@ extension KeepAliveController {
case notStarted
case userOff
case noTasks
- case helperUnavailable
- case helperRefreshing
+ case powerHelperUnavailable
+ case powerHelperRefreshing
case terminating
case lowBattery
case limitReached
@@ -131,52 +131,52 @@ extension KeepAliveController {
let blockReason: SleepBlockReason?
let enabled: Bool
let tasks: Bool
- let helper: HelperStatus
+ let powerHelper: PowerHelperStatus
let refreshing: Bool
let battery: Bool
let limited: Bool
}
}
-nonisolated enum HelperPackageIssue: Equatable, Sendable {
+nonisolated enum PowerHelperPackageIssue: Equatable, Sendable {
case missing
case invalid
var message: String {
switch self {
case .missing:
- KeepAliveLocalizedMessage.helperAssetsMissing
+ KeepAliveLocalizedMessage.powerHelperAssetsMissing
case .invalid:
- KeepAliveLocalizedMessage.helperAssetsInvalid
+ KeepAliveLocalizedMessage.powerHelperAssetsInvalid
}
}
}
nonisolated enum KeepAliveLocalizedMessage {
- static let helperAssetsMissing = String(localized: "helper.error.assets-missing")
- static let helperAssetsInvalid = String(localized: "helper.error.assets-invalid")
- static let registrationFailed = String(localized: "helper.error.registration-failed")
- static let updateFailed = String(localized: "helper.error.update-failed")
+ static let powerHelperAssetsMissing = String(localized: "power-helper.error.assets-missing")
+ static let powerHelperAssetsInvalid = String(localized: "power-helper.error.assets-invalid")
+ static let registrationFailed = String(localized: "power-helper.error.registration-failed")
+ static let updateFailed = String(localized: "power-helper.error.update-failed")
static let preventIdleSleepFailed = String(localized: "keep-alive.error.prevent-idle-sleep-failed")
static let toggleSleepFailed = String(localized: "keep-alive.error.toggle-sleep-failed")
static let restoreIdleSleepFailed = String(localized: "keep-alive.error.restore-idle-sleep-failed")
- static let connectionFailed = String(localized: "helper.error.connection-failed")
- static let noResponse = String(localized: "helper.error.no-response")
+ static let connectionFailed = String(localized: "power-helper.error.connection-failed")
+ static let noResponse = String(localized: "power-helper.error.no-response")
static let retryLimitReached = String(localized: "keep-alive.error.retry-limit-reached")
- static let invalidHelperInterface = String(localized: "helper.error.invalid-interface")
- static let connectionInterrupted = String(localized: "helper.error.connection-interrupted")
+ static let invalidPowerHelperInterface = String(localized: "power-helper.error.invalid-interface")
+ static let connectionInterrupted = String(localized: "power-helper.error.connection-interrupted")
static let autoResetWakeScheduleFailed = String(localized: "auto-reset.error.wake-schedule-failed")
}
nonisolated enum KeepAliveError: LocalizedError {
- case invalidHelperProxy
+ case invalidPowerHelperProxy
case connectionInterrupted
case wakeScheduleCancellationFailed
var errorDescription: String? {
switch self {
- case .invalidHelperProxy:
- KeepAliveLocalizedMessage.invalidHelperInterface
+ case .invalidPowerHelperProxy:
+ KeepAliveLocalizedMessage.invalidPowerHelperInterface
case .connectionInterrupted:
KeepAliveLocalizedMessage.connectionInterrupted
case .wakeScheduleCancellationFailed:
diff --git a/CodexBar/Services/KeepAlive/HelperConfiguration.swift b/CodexBar/Services/KeepAlive/PowerHelperConfiguration.swift
similarity index 63%
rename from CodexBar/Services/KeepAlive/HelperConfiguration.swift
rename to CodexBar/Services/KeepAlive/PowerHelperConfiguration.swift
index 1765226..2a3a977 100644
--- a/CodexBar/Services/KeepAlive/HelperConfiguration.swift
+++ b/CodexBar/Services/KeepAlive/PowerHelperConfiguration.swift
@@ -5,7 +5,7 @@ import Security
import ServiceManagement
@MainActor
-enum HelperConfiguration {
+enum PowerHelperConfiguration {
static let registrationRetryDelays: [Duration] = [
.milliseconds(500),
.seconds(1),
@@ -19,10 +19,10 @@ enum HelperConfiguration {
.seconds(2)
]
static let requestTimeout = Duration.seconds(
- CodexBarHelperIPC.requestTimeoutSeconds
+ CodexBarPowerHelperIPC.requestTimeoutSeconds
)
static let externalObservationInterval = Duration.seconds(
- CodexBarHelperIPC.externalCheckIntervalSeconds
+ CodexBarPowerHelperIPC.externalCheckIntervalSeconds
)
static let sleepToggleRetryDelays: [Duration] = [
.seconds(2),
@@ -47,64 +47,66 @@ enum HelperConfiguration {
.milliseconds(250),
.seconds(1)
]
+ private nonisolated static let signatureValidationFlags = SecCSFlags(
+ rawValue: kSecCSCheckAllArchitectures | kSecCSStrictValidate
+ ).union(.noNetworkAccess)
- nonisolated static func validatePackage(appURL: URL, machServiceName: String) -> HelperPackageIssue? {
- let managerURL = HelperManagement.bundleURL(in: appURL)
- let helperURL = managerURL.appending(path: "Contents/Resources/CodexBarHelper")
- let plistURL = managerURL.appending(path: "Contents/Library/LaunchDaemons/\(machServiceName).plist")
+ nonisolated static func validatePackage(appURL: URL, serviceIdentifier: String) -> PowerHelperPackageIssue? {
+ let managerURL = PowerHelperManagement.bundleURL(in: appURL)
+ let powerHelperURL = managerURL.appending(path: "Contents/Helpers/CodexBarPowerHelper")
+ let plistURL = managerURL.appending(path: "Contents/Library/LaunchDaemons/\(CodexBarPowerHelperIPC.daemonPlistName)")
let fileManager = FileManager.default
guard fileManager.fileExists(atPath: plistURL.path),
- fileManager.isExecutableFile(atPath: helperURL.path) else {
+ fileManager.isExecutableFile(atPath: powerHelperURL.path) else {
return .missing
}
guard let manager = Bundle(url: managerURL),
- manager.bundleIdentifier == HelperManagement.bundleIdentifier,
+ manager.bundleIdentifier == PowerHelperManagement.bundleIdentifier,
manager.executableURL.map({ fileManager.isExecutableFile(atPath: $0.path) }) == true,
let plistData = try? Data(contentsOf: plistURL),
let plist = try? PropertyListSerialization.propertyList(from: plistData, format: nil) as? [String: Any],
- plist["Label"] as? String == machServiceName,
- plist["BundleProgram"] as? String == "Contents/Resources/CodexBarHelper",
- plist["AssociatedBundleIdentifiers"] as? [String] == [HelperManagement.bundleIdentifier],
- (plist["MachServices"] as? [String: Any])?[machServiceName] as? Bool == true else {
+ plist["Label"] as? String == serviceIdentifier,
+ plist["BundleProgram"] as? String == "Contents/Helpers/CodexBarPowerHelper",
+ plist["AssociatedBundleIdentifiers"] as? [String] == [PowerHelperManagement.bundleIdentifier],
+ (plist["MachServices"] as? [String: Any])?[serviceIdentifier] as? Bool == true else {
return .invalid
}
- guard helperSignatureIsValid(helperURL: managerURL, appURL: appURL, machServiceName: HelperManagement.bundleIdentifier),
- helperSignatureIsValid(helperURL: helperURL, appURL: appURL, machServiceName: machServiceName) else {
- return .invalid
- }
- return nil
- }
-
- private nonisolated static func helperSignatureIsValid(helperURL: URL, appURL: URL, machServiceName: String) -> Bool {
- let flags = SecCSFlags(rawValue: kSecCSCheckAllArchitectures | kSecCSStrictValidate).union(.noNetworkAccess)
var appCode: SecStaticCode?
var signingInformation: CFDictionary?
guard SecStaticCodeCreateWithPath(appURL as CFURL, SecCSFlags(), &appCode) == errSecSuccess,
let appCode,
- SecStaticCodeCheckValidity(appCode, flags, nil) == errSecSuccess,
+ SecStaticCodeCheckValidity(appCode, signatureValidationFlags, nil) == errSecSuccess,
SecCodeCopySigningInformation(appCode, SecCSFlags(rawValue: kSecCSSigningInformation), &signingInformation) == errSecSuccess,
let values = signingInformation as NSDictionary?,
let teamIdentifier = values[kSecCodeInfoTeamIdentifier] as? String,
!teamIdentifier.isEmpty,
teamIdentifier.unicodeScalars.allSatisfy(CharacterSet.alphanumerics.contains),
- !machServiceName.isEmpty,
- machServiceName.unicodeScalars.allSatisfy(CharacterSet.alphanumerics.union(CharacterSet(charactersIn: ".-")).contains) else {
+ signatureIsValid(codeURL: managerURL, teamIdentifier: teamIdentifier, expectedIdentifier: PowerHelperManagement.bundleIdentifier),
+ signatureIsValid(codeURL: powerHelperURL, teamIdentifier: teamIdentifier, expectedIdentifier: serviceIdentifier) else {
+ return .invalid
+ }
+ return nil
+ }
+
+ private nonisolated static func signatureIsValid(codeURL: URL, teamIdentifier: String, expectedIdentifier: String) -> Bool {
+ guard !expectedIdentifier.isEmpty,
+ expectedIdentifier.unicodeScalars.allSatisfy(CharacterSet.alphanumerics.union(CharacterSet(charactersIn: ".-")).contains) else {
return false
}
- // App 资源封印覆盖 plist, helper 另按客户端校验使用的签名团队验证全部架构
+ // App 资源封印覆盖 plist, Power Helper 另按客户端校验使用的签名团队验证全部架构
let requirementText = "anchor apple generic"
+ " and certificate leaf[subject.OU] = \"\(teamIdentifier)\""
- + " and identifier \"\(machServiceName)\""
+ + " and identifier \"\(expectedIdentifier)\""
var requirement: SecRequirement?
- var helperCode: SecStaticCode?
+ var code: SecStaticCode?
guard SecRequirementCreateWithString(requirementText as CFString, SecCSFlags(), &requirement) == errSecSuccess,
let requirement,
- SecStaticCodeCreateWithPath(helperURL as CFURL, SecCSFlags(), &helperCode) == errSecSuccess,
- let helperCode else {
+ SecStaticCodeCreateWithPath(codeURL as CFURL, SecCSFlags(), &code) == errSecSuccess,
+ let code else {
return false
}
- return SecStaticCodeCheckValidity(helperCode, flags, requirement) == errSecSuccess
+ return SecStaticCodeCheckValidity(code, signatureValidationFlags, requirement) == errSecSuccess
}
static func registrationNeedsRefresh(defaults: UserDefaults, fingerprint: String) -> Bool {
@@ -116,7 +118,7 @@ enum HelperConfiguration {
requiresSleepReset: Bool,
fingerprint: String
) -> String {
- // 待完成重置是跨 Helper 版本的欠账, 后续更新只能转交给新指纹, 不能清除
+ // 待完成重置是跨 Power Helper 版本的欠账, 后续更新只能转交给新指纹, 不能清除
let hasPendingSleepReset = defaults.string(forKey: pendingUpdateIdentifierKey) != nil
if requiresSleepReset || hasPendingSleepReset {
defaults.set(fingerprint, forKey: pendingUpdateIdentifierKey)
@@ -146,7 +148,7 @@ enum HelperConfiguration {
static func recordRegistration(
defaults: UserDefaults,
- status: KeepAliveController.HelperStatus,
+ status: KeepAliveController.PowerHelperStatus,
fingerprint: String
) {
guard status.isRegisteredOrAwaitingApproval else {
@@ -161,7 +163,7 @@ enum HelperConfiguration {
&& error.code == operationNotPermittedErrorCode
}
- static func registerRefreshedHelper(_ service: HelperManagerClient) async throws {
+ static func registerRefreshedPowerHelper(_ service: PowerHelperManagerClient) async throws {
await Task.yield()
var retryDelays = registrationRetryDelays.makeIterator()
@@ -179,24 +181,24 @@ enum HelperConfiguration {
}
}
- private static let registrationFingerprintKey = "KeepAlive.helperRegistrationFingerprint"
- private static let pendingUpdateIdentifierKey = "KeepAlive.pendingHelperUpdateIdentifier"
+ private static let registrationFingerprintKey = "PowerHelper.registrationFingerprint"
+ private static let pendingUpdateIdentifierKey = "PowerHelper.pendingUpdateIdentifier"
private static let operationNotPermittedErrorCode = 1
- nonisolated static func inspectPackage(appURL: URL, machServiceName: String) -> HelperPackageSnapshot {
- if let issue = validatePackage(appURL: appURL, machServiceName: machServiceName) {
- return HelperPackageSnapshot(issue: issue, fingerprint: nil)
+ nonisolated static func inspectPackage(appURL: URL, serviceIdentifier: String) -> PowerHelperPackageSnapshot {
+ if let issue = validatePackage(appURL: appURL, serviceIdentifier: serviceIdentifier) {
+ return PowerHelperPackageSnapshot(issue: issue, fingerprint: nil)
}
- let managerURL = HelperManagement.bundleURL(in: appURL)
- let managerExecutableURL = managerURL.appending(path: "Contents/MacOS/\(HelperManagement.executableName)")
- let helperExecutableURL = managerURL.appending(path: "Contents/Resources/CodexBarHelper")
- let daemonPlistURL = managerURL.appending(path: "Contents/Library/LaunchDaemons/\(machServiceName).plist")
+ let managerURL = PowerHelperManagement.bundleURL(in: appURL)
+ let managerExecutableURL = managerURL.appending(path: "Contents/MacOS/\(PowerHelperManagement.executableName)")
+ let powerHelperExecutableURL = managerURL.appending(path: "Contents/Helpers/CodexBarPowerHelper")
+ let daemonPlistURL = managerURL.appending(path: "Contents/Library/LaunchDaemons/\(CodexBarPowerHelperIPC.daemonPlistName)")
guard let managerData = try? Data(contentsOf: managerExecutableURL, options: .mappedIfSafe),
let managerInfo = try? Data(contentsOf: managerURL.appending(path: "Contents/Info.plist")),
let managerSeal = try? Data(contentsOf: managerURL.appending(path: "Contents/_CodeSignature/CodeResources")),
- let helperData = try? Data(contentsOf: helperExecutableURL, options: .mappedIfSafe),
+ let powerHelperData = try? Data(contentsOf: powerHelperExecutableURL, options: .mappedIfSafe),
let daemonPlistData = try? Data(contentsOf: daemonPlistURL, options: .mappedIfSafe) else {
- return HelperPackageSnapshot(issue: .invalid, fingerprint: nil)
+ return PowerHelperPackageSnapshot(issue: .invalid, fingerprint: nil)
}
var hasher = SHA256()
@@ -204,35 +206,35 @@ enum HelperConfiguration {
(managerExecutableURL.lastPathComponent, managerData),
("Info.plist", managerInfo),
("CodeResources", managerSeal),
- (helperExecutableURL.lastPathComponent, helperData),
+ (powerHelperExecutableURL.lastPathComponent, powerHelperData),
(daemonPlistURL.lastPathComponent, daemonPlistData)
] {
hasher.update(data: Data("\(name)\n\(data.count)\n".utf8))
hasher.update(data: data)
}
- return HelperPackageSnapshot(issue: nil, fingerprint: hasher.finalize().map { String(format: "%02x", $0) }.joined())
+ return PowerHelperPackageSnapshot(issue: nil, fingerprint: hasher.finalize().map { String(format: "%02x", $0) }.joined())
}
}
-nonisolated struct HelperPackageSnapshot {
- let issue: HelperPackageIssue?
+nonisolated struct PowerHelperPackageSnapshot {
+ let issue: PowerHelperPackageIssue?
let fingerprint: String?
}
@MainActor
-final class HelperPackageValidation: ObservableObject {
+final class PowerHelperPackageValidation: ObservableObject {
/// 同一轮校验提供注册与就绪判断共用的指纹, 不在主 actor 读取包文件
- @Published private(set) var issue: HelperPackageIssue?
+ @Published private(set) var issue: PowerHelperPackageIssue?
private(set) var fingerprint: String?
var onValidated: (() -> Void)?
- private let inspect: @Sendable () async -> HelperPackageSnapshot
+ private let inspect: @Sendable () async -> PowerHelperPackageSnapshot
private var task: Task<Void, Never>?
- init(inspect: @escaping @Sendable () async -> HelperPackageSnapshot = {
+ init(inspect: @escaping @Sendable () async -> PowerHelperPackageSnapshot = {
let appURL = Bundle.main.bundleURL
- let machServiceName = CodexBarHelperIPC.machServiceName
+ let serviceIdentifier = CodexBarPowerHelperIPC.serviceIdentifier
return await Task.detached(priority: .utility) {
- HelperConfiguration.inspectPackage(appURL: appURL, machServiceName: machServiceName)
+ PowerHelperConfiguration.inspectPackage(appURL: appURL, serviceIdentifier: serviceIdentifier)
}.value
}) {
self.inspect = inspect
diff --git a/CodexBar/Services/KeepAlive/HelperManagerClient.swift b/CodexBar/Services/KeepAlive/PowerHelperManagerClient.swift
similarity index 78%
rename from CodexBar/Services/KeepAlive/HelperManagerClient.swift
rename to CodexBar/Services/KeepAlive/PowerHelperManagerClient.swift
index a6fb7bd..0491516 100644
--- a/CodexBar/Services/KeepAlive/HelperManagerClient.swift
+++ b/CodexBar/Services/KeepAlive/PowerHelperManagerClient.swift
@@ -2,8 +2,8 @@ import Foundation
import ServiceManagement
/// 管理进程只在查询或变更注册时启动, 输出与执行时间由共用进程内核约束
-actor HelperManagerClient {
- private let executeCommand: @Sendable (HelperManagement.Command) async throws -> SMAppService.Status
+actor PowerHelperManagerClient {
+ private let executeCommand: @Sendable (PowerHelperManagement.Command) async throws -> SMAppService.Status
private let retryDelay: Duration
private var pending: Task<SMAppService.Status, Error>?
private var generation: UInt64 = 0
@@ -11,7 +11,7 @@ actor HelperManagerClient {
init(
appURL: URL = Bundle.main.bundleURL,
retryDelay: Duration = .seconds(1),
- executeCommand: (@Sendable (HelperManagement.Command) async throws -> SMAppService.Status)? = nil
+ executeCommand: (@Sendable (PowerHelperManagement.Command) async throws -> SMAppService.Status)? = nil
) {
self.executeCommand = executeCommand ?? { command in
try await Self.execute(command, appURL: appURL)
@@ -19,7 +19,7 @@ actor HelperManagerClient {
self.retryDelay = retryDelay
}
- func perform(_ command: HelperManagement.Command) async throws -> SMAppService.Status {
+ func perform(_ command: PowerHelperManagement.Command) async throws -> SMAppService.Status {
let previous = pending
let executeCommand = executeCommand
let retryDelay = retryDelay
@@ -58,9 +58,9 @@ actor HelperManagerClient {
}
}
- private nonisolated static func execute(_ command: HelperManagement.Command, appURL: URL) async throws -> SMAppService.Status {
- let executable = HelperManagement.bundleURL(in: appURL)
- .appending(path: "Contents/MacOS/\(HelperManagement.executableName)")
+ private nonisolated static func execute(_ command: PowerHelperManagement.Command, appURL: URL) async throws -> SMAppService.Status {
+ let executable = PowerHelperManagement.bundleURL(in: appURL)
+ .appending(path: "Contents/MacOS/\(PowerHelperManagement.executableName)")
let result = await BoundedProcess.runAsync(
executable: executable,
arguments: [command.rawValue],
@@ -74,8 +74,8 @@ actor HelperManagerClient {
return try Self.status(from: result.standardOutput.data, command: command)
}
- nonisolated static func status(from data: Data, command: HelperManagement.Command) throws -> SMAppService.Status {
- let reply = try JSONDecoder().decode(HelperManagement.Reply.self, from: data)
+ nonisolated static func status(from data: Data, command: PowerHelperManagement.Command) throws -> SMAppService.Status {
+ let reply = try JSONDecoder().decode(PowerHelperManagement.Reply.self, from: data)
guard let status = SMAppService.Status(rawValue: reply.status) else {
throw ClientError.invalidStatus
}
diff --git a/CodexBar/Services/KeepAlive/HelperStatusMonitor.swift b/CodexBar/Services/KeepAlive/PowerHelperStatusMonitor.swift
similarity index 88%
rename from CodexBar/Services/KeepAlive/HelperStatusMonitor.swift
rename to CodexBar/Services/KeepAlive/PowerHelperStatusMonitor.swift
index e6ca15d..f95591b 100644
--- a/CodexBar/Services/KeepAlive/HelperStatusMonitor.swift
+++ b/CodexBar/Services/KeepAlive/PowerHelperStatusMonitor.swift
@@ -1,7 +1,7 @@
import Foundation
import os
-struct HelperRuntimeStatus {
+struct PowerHelperRuntimeStatus {
let ownership: CodexBarSleepOwnershipState
let activeClientCount: Int
let sleepDisabled: Bool
@@ -24,10 +24,10 @@ struct HelperRuntimeStatus {
}
@MainActor
-final class HelperStatusMonitor {
+final class PowerHelperStatusMonitor {
enum WakeScheduleResult {
case success
- case helperFailure(Int32)
+ case powerHelperFailure(Int32)
case connectionFailure(Error)
case timedOut
case cancelled
@@ -47,7 +47,7 @@ final class HelperStatusMonitor {
timeout: Duration,
onConnectionFailure: @escaping (Error) -> Void,
onTimeout: @escaping () -> Void
- ) async -> HelperRuntimeStatus? {
+ ) async -> PowerHelperRuntimeStatus? {
let result = await performRequest(
connection: connection,
operation: .status,
@@ -65,12 +65,12 @@ final class HelperStatusMonitor {
"clients=\(activeClientCount)"
)
AppLog.keepAlive.error(
- "Helper 运行状态无效: \(details, privacy: .public)"
+ "Power Helper 运行状态无效: \(details, privacy: .public)"
)
case .timedOut:
let wait = LogDuration.seconds(timeout)
AppLog.keepAlive.error(
- "Helper 状态请求超时: timeout=\(wait, privacy: .public)"
+ "Power Helper 状态请求超时: timeout=\(wait, privacy: .public)"
)
onTimeout()
case .updateReset, .wakeSchedule, .cancelled:
@@ -95,7 +95,7 @@ final class HelperStatusMonitor {
case let .updateReset(exitCode):
guard exitCode == 0 else {
AppLog.keepAlive.error(
- "Helper 更新后睡眠状态检查失败: exit=\(exitCode)"
+ "Power Helper 更新后睡眠状态检查失败: exit=\(exitCode)"
)
return false
}
@@ -105,7 +105,7 @@ final class HelperStatusMonitor {
case .timedOut:
let wait = LogDuration.seconds(timeout)
AppLog.keepAlive.error(
- "Helper 更新后睡眠状态检查超时: timeout=\(wait, privacy: .public)"
+ "Power Helper 更新后睡眠状态检查超时: timeout=\(wait, privacy: .public)"
)
onTimeout()
case .status, .wakeSchedule, .invalidResponse, .cancelled:
@@ -126,7 +126,7 @@ final class HelperStatusMonitor {
)
switch result {
case let .wakeSchedule(exitCode):
- return exitCode == 0 ? .success : .helperFailure(exitCode)
+ return exitCode == 0 ? .success : .powerHelperFailure(exitCode)
case let .connectionFailure(error):
return .connectionFailure(error)
case .timedOut:
@@ -198,19 +198,19 @@ final class HelperStatusMonitor {
)
}
}
- guard let helper = connection.remoteObjectProxyWithErrorHandler(errorHandler)
- as? CodexBarHelperProtocol else {
+ guard let powerHelper = connection.remoteObjectProxyWithErrorHandler(errorHandler)
+ as? CodexBarPowerHelperProtocol else {
finishRequest(.connectionFailure(RequestError.invalidProxy), generation: generation)
return
}
- send(operation, to: helper, generation: generation)
+ send(operation, to: powerHelper, generation: generation)
}
}
private func send(
_ operation: RequestOperation,
- to helper: CodexBarHelperProtocol,
+ to powerHelper: CodexBarPowerHelperProtocol,
generation: UInt64
) {
switch operation {
@@ -234,7 +234,7 @@ final class HelperStatusMonitor {
}
self?.finishRequest(
.status(
- HelperRuntimeStatus(
+ PowerHelperRuntimeStatus(
ownership: ownership,
activeClientCount: activeClientCount,
sleepDisabled: sleepDisabled
@@ -244,7 +244,7 @@ final class HelperStatusMonitor {
)
}
}
- helper.getSleepPreventionStatus(reply: reply)
+ powerHelper.getSleepPreventionStatus(reply: reply)
case let .updateReset(updateIdentifier):
let reply: @Sendable (Int32) -> Void = { [weak self] exitCode in
Task { @MainActor in
@@ -254,7 +254,7 @@ final class HelperStatusMonitor {
)
}
}
- helper.resetSleepAfterUpdate(updateIdentifier, reply: reply)
+ powerHelper.resetSleepAfterUpdate(updateIdentifier, reply: reply)
case let .wakeSchedule(unixTimestamp):
let reply: @Sendable (Int32) -> Void = { [weak self] exitCode in
Task { @MainActor in
@@ -264,7 +264,7 @@ final class HelperStatusMonitor {
)
}
}
- helper.setAutoResetWakeSchedule(unixTimestamp, reply: reply)
+ powerHelper.setAutoResetWakeSchedule(unixTimestamp, reply: reply)
}
}
@@ -280,7 +280,7 @@ final class HelperStatusMonitor {
}
private enum RequestResult {
- case status(HelperRuntimeStatus)
+ case status(PowerHelperRuntimeStatus)
case updateReset(exitCode: Int32)
case wakeSchedule(exitCode: Int32)
case connectionFailure(Error)
diff --git a/CodexBar/Services/Notifications/NotificationSoundOption.swift b/CodexBar/Services/Notifications/NotificationSoundOption.swift
index 9a730b3..715dd0a 100644
--- a/CodexBar/Services/Notifications/NotificationSoundOption.swift
+++ b/CodexBar/Services/Notifications/NotificationSoundOption.swift
@@ -7,24 +7,17 @@ import UserNotifications
/// `id` 是落在 UserDefaults 里的持久化值, 系统提示音取文件名小写形式, 与旧版本的枚举值天然对齐
struct NotificationSoundOption: Identifiable, Hashable {
let id: String
- let title: String
+ let localizedTitle: String
private let source: SoundSource
- var localizedTitle: String {
- switch source {
- case .silent:
- String(localized: "notification.sound.silent")
- case .systemDefault:
- String(localized: "notification.sound.default")
- case .system, .bundled:
- title
- }
- }
-
- static let silent = NotificationSoundOption(id: "silent", title: "静音", source: .silent)
+ static let silent = NotificationSoundOption(
+ id: "silent",
+ localizedTitle: String(localized: "notification.sound.silent"),
+ source: .silent
+ )
static let systemDefault = NotificationSoundOption(
id: "systemDefault",
- title: "默认",
+ localizedTitle: String(localized: "notification.sound.default"),
source: .systemDefault
)
@@ -189,7 +182,7 @@ struct NotificationSoundOption: Identifiable, Hashable {
) -> NotificationSoundOption {
NotificationSoundOption(
id: id,
- title: title,
+ localizedTitle: title,
source: .bundled("CodexBar-\(resource ?? title)")
)
}
@@ -217,7 +210,7 @@ struct NotificationSoundOption: Identifiable, Hashable {
sounds.append(
NotificationSoundOption(
id: id,
- title: title,
+ localizedTitle: title,
source: .system(directoryURL.appendingPathComponent(fileName))
)
)
@@ -225,7 +218,7 @@ struct NotificationSoundOption: Identifiable, Hashable {
}
return sounds.sorted {
- $0.title.localizedStandardCompare($1.title) == .orderedAscending
+ $0.localizedTitle.localizedStandardCompare($1.localizedTitle) == .orderedAscending
}
}
diff --git a/CodexBar/Services/Support/AppLog.swift b/CodexBar/Services/Support/AppLog.swift
index 3c818b4..87c5919 100644
--- a/CodexBar/Services/Support/AppLog.swift
+++ b/CodexBar/Services/Support/AppLog.swift
@@ -45,7 +45,7 @@ nonisolated enum LogTrigger: String {
case settings
case retry
case taskChanged
- case helperRegistered
+ case powerHelperRegistered
case termination
case limitReached
/// 电量或供电方式变化
diff --git a/CodexBar/Views/Menu/CodexStatusMenuView.swift b/CodexBar/Views/Menu/CodexStatusMenuView.swift
index 269b8ba..2411cb1 100644
--- a/CodexBar/Views/Menu/CodexStatusMenuView.swift
+++ b/CodexBar/Views/Menu/CodexStatusMenuView.swift
@@ -40,7 +40,7 @@ struct CodexStatusMenuView: View {
// 活动状态与时间变化由卡片自行观察, 避免刷新整个菜单树
let activityMonitor: ActivityMonitor
@ObservedObject var syncSettings: SyncSettings
- // 同 activityMonitor, 交给活动卡片自行观察, 不让 helper 状态变化重算整个菜单树
+ // 同 activityMonitor, 交给活动卡片自行观察, 不让 Power Helper 状态变化重算整个菜单树
let keepAliveController: KeepAliveController
@ObservedObject var menuSurfaceVisibility: MenuSurfaceVisibilityState
@ObservedObject var animationState: MenuSurfaceAnimationState
diff --git a/CodexBar/Views/Settings/AppSettingsView.swift b/CodexBar/Views/Settings/AppSettingsView.swift
index f361e76..8a99928 100644
--- a/CodexBar/Views/Settings/AppSettingsView.swift
+++ b/CodexBar/Views/Settings/AppSettingsView.swift
@@ -31,7 +31,7 @@ struct AppSettingsView: View {
@State private var isShowingRebuildConfirmation = false
@State private var isRebuildingHistoryData = false
@State private var rebuildResult: RebuildResult?
- @State private var helperFeatureConfirmation: HelperFeatureConfirmation?
+ @State private var powerHelperFeatureConfirmation: PowerHelperFeatureConfirmation?
var body: some View {
VStack(spacing: 0) {
@@ -96,7 +96,7 @@ struct AppSettingsView: View {
loginItemSettings.refresh()
selectedRebuildRange = nil
isShowingRebuildConfirmation = false
- helperFeatureConfirmation = nil
+ powerHelperFeatureConfirmation = nil
rebuildResult = nil
}
.onChange(of: selectedTab) { _, _ in
@@ -151,16 +151,16 @@ struct AppSettingsView: View {
Text(verbatim: result.message)
}
.alert(
- helperFeatureConfirmation?.title ?? Text(verbatim: ""),
+ powerHelperFeatureConfirmation?.title ?? Text(verbatim: ""),
isPresented: Binding(
- get: { helperFeatureConfirmation != nil },
+ get: { powerHelperFeatureConfirmation != nil },
set: {
if !$0 {
- helperFeatureConfirmation = nil
+ powerHelperFeatureConfirmation = nil
}
}
),
- presenting: helperFeatureConfirmation
+ presenting: powerHelperFeatureConfirmation
) { feature in
Button("common.action.enable", role: .destructive) {
switch feature {
@@ -170,7 +170,7 @@ struct AppSettingsView: View {
}
Button("common.action.cancel", role: .cancel) {}
} message: { feature in
- Text(verbatim: feature.message(helperStatus: keepAliveController.helperStatus))
+ Text(verbatim: feature.message(powerHelperStatus: keepAliveController.powerHelperStatus))
}
}
}
@@ -317,7 +317,7 @@ private extension AppSettingsView {
VStack(alignment: .leading, spacing: Metrics.rowSpacing) {
codexVersionSection
LiquidGlassDivider()
- HelperInstallationStatusRow(status: keepAliveController.helperInstallationStatus)
+ PowerHelperInstallationStatusRow(status: keepAliveController.powerHelperInstallationStatus)
LiquidGlassDivider()
versionRow
LiquidGlassDivider()
@@ -468,7 +468,7 @@ private extension AppSettingsView {
var autoResetRow: some View {
let isEnabled = autoResetSettings.isEnabled
- let canShowOptions = isEnabled && keepAliveController.helperStatus == .enabled
+ let canShowOptions = isEnabled && keepAliveController.powerHelperStatus == .enabled
let caption = autoResetCaption
return VStack(alignment: .leading, spacing: 4) {
@@ -479,7 +479,7 @@ private extension AppSettingsView {
get: { autoResetSettings.isEnabled },
set: { enabled in
if enabled {
- helperFeatureConfirmation = .autoReset
+ powerHelperFeatureConfirmation = .autoReset
} else {
autoResetSettings.setEnabled(enabled)
}
@@ -516,26 +516,26 @@ private extension AppSettingsView {
guard autoResetSettings.isEnabled else {
return nil
}
- if let caption = helperInstallationCaption {
+ if let caption = powerHelperInstallationCaption {
return caption
}
- guard let errorMessage = keepAliveController.helperRegistrationErrorMessage
+ guard let errorMessage = keepAliveController.powerHelperRegistrationErrorMessage
?? keepAliveController.autoResetWakeScheduleErrorMessage else {
return nil
}
return SettingsStatusCaption(message: errorMessage, isError: true)
}
- var helperInstallationCaption: SettingsStatusCaption? {
- switch keepAliveController.helperInstallationStatus {
+ var powerHelperInstallationCaption: SettingsStatusCaption? {
+ switch keepAliveController.powerHelperInstallationStatus {
case .requiresApproval:
SettingsStatusCaption(
- message: String(localized: "helper.status.authorization-required"),
+ message: String(localized: "power-helper.status.authorization-required"),
showsSystemSettingsButton: true
)
case .notInstalled:
SettingsStatusCaption(
- message: String(localized: "helper.status.not-registered")
+ message: String(localized: "power-helper.status.not-registered")
)
case let .unavailable(message):
SettingsStatusCaption(message: message, isError: true)
@@ -557,7 +557,7 @@ private extension AppSettingsView {
get: { keepAliveController.isEnabled },
set: { enabled in
if enabled {
- helperFeatureConfirmation = .keepAlive
+ powerHelperFeatureConfirmation = .keepAlive
} else {
keepAliveController.setEnabled(false)
}
@@ -624,7 +624,7 @@ private extension AppSettingsView {
guard keepAliveController.isEnabled else {
return nil
}
- if let caption = helperInstallationCaption {
+ if let caption = powerHelperInstallationCaption {
return caption
}
if let errorMessage = keepAliveController.errorMessage {
@@ -640,7 +640,7 @@ private extension AppSettingsView {
// 低电量拦下时开关开着却不防睡眠, 不留一句无从解释
// 判定用 isLowBatteryBlocking 而不是 isLowBatteryActive: 后者在没有任务时也成立, 那时无话可说
- // 它成立即意味着 helper 已就绪, 所以排在下面那个 switch 之前不影响 helper 类问题的呈现
+ // 它成立即意味着 Power Helper 已就绪, 所以排在下面那个 switch 之前不影响 Power Helper 类问题的呈现
// 提示不写具体电量, 因为滞回会让保护持续到电量超过恢复阈值
if keepAliveController.isLowBatteryBlocking {
return SettingsStatusCaption(message: String(localized: "keep-alive.status.low-battery"))
@@ -781,7 +781,7 @@ private extension AppSettingsView {
}
/// 防睡眠不在这里刷: 控制器自己订阅了 didBecomeActive, 窗口打开也走 refreshSettingsState
- /// 再调一次会让每次激活都多跑一遍电源读取 helper 状态查询和 helper 二进制哈希
+ /// 再调一次会让每次激活都多跑一遍电源读取 Power Helper 状态查询和 Power Helper 二进制哈希
func refreshStatusRows() {
refreshCodexVersionSection()
refreshRebuildableDates()
diff --git a/CodexBar/Views/Settings/HelperFeatureConfirmation.swift b/CodexBar/Views/Settings/PowerHelperFeatureConfirmation.swift
similarity index 64%
rename from CodexBar/Views/Settings/HelperFeatureConfirmation.swift
rename to CodexBar/Views/Settings/PowerHelperFeatureConfirmation.swift
index 4a160ce..634993d 100644
--- a/CodexBar/Views/Settings/HelperFeatureConfirmation.swift
+++ b/CodexBar/Views/Settings/PowerHelperFeatureConfirmation.swift
@@ -1,6 +1,6 @@
import SwiftUI
-enum HelperFeatureConfirmation {
+enum PowerHelperFeatureConfirmation {
case autoReset
case keepAlive
@@ -22,12 +22,12 @@ enum HelperFeatureConfirmation {
}
}
- func message(helperStatus: KeepAliveController.HelperStatus) -> String {
- switch helperStatus {
+ func message(powerHelperStatus: KeepAliveController.PowerHelperStatus) -> String {
+ switch powerHelperStatus {
case .notRegistered, .notFound:
- "\(String(localized: "helper.status.install-and-authorize"))\n\(details)"
+ "\(String(localized: "power-helper.status.install-and-authorize"))\n\(details)"
case .requiresApproval:
- "\(String(localized: "helper.status.installed-needs-authorization"))\n\(details)"
+ "\(String(localized: "power-helper.status.installed-needs-authorization"))\n\(details)"
case .enabled:
details
}
diff --git a/CodexBar/Views/Settings/HelperInstallationStatusRow.swift b/CodexBar/Views/Settings/PowerHelperInstallationStatusRow.swift
similarity index 63%
rename from CodexBar/Views/Settings/HelperInstallationStatusRow.swift
rename to CodexBar/Views/Settings/PowerHelperInstallationStatusRow.swift
index bac202e..2156018 100644
--- a/CodexBar/Views/Settings/HelperInstallationStatusRow.swift
+++ b/CodexBar/Views/Settings/PowerHelperInstallationStatusRow.swift
@@ -1,7 +1,7 @@
import SwiftUI
-struct HelperInstallationStatusRow: View {
- let status: KeepAliveController.HelperInstallationStatus
+struct PowerHelperInstallationStatusRow: View {
+ let status: KeepAliveController.PowerHelperInstallationStatus
var body: some View {
HStack(spacing: SettingsRowMetrics.spacing) {
@@ -9,7 +9,7 @@ struct HelperInstallationStatusRow: View {
.frame(width: SettingsRowMetrics.iconWidth)
.foregroundStyle(.tint)
- Text("settings.about.helper.title")
+ Text("settings.about.power-helper.title")
Spacer()
@@ -24,13 +24,13 @@ struct HelperInstallationStatusRow: View {
private var statusPresentation: (text: LocalizedStringKey, color: Color) {
switch status {
case .notInstalled:
- ("settings.about.helper.not-installed", .gray)
+ ("settings.about.power-helper.not-installed", .gray)
case .authorized:
- ("settings.about.helper.authorized", .green)
+ ("settings.about.power-helper.authorized", .green)
case .requiresApproval:
- ("settings.about.helper.requires-approval", .orange)
+ ("settings.about.power-helper.requires-approval", .orange)
case .unavailable:
- ("settings.about.helper.unavailable", .red)
+ ("settings.about.power-helper.unavailable", .red)
}
}
}
diff --git a/CodexBarHelper/app.zabrian.codexbar.helper.plist b/CodexBarHelper/Power/Daemon/CodexBarPowerHelper.Debug.plist
similarity index 66%
rename from CodexBarHelper/app.zabrian.codexbar.helper.plist
rename to CodexBarHelper/Power/Daemon/CodexBarPowerHelper.Debug.plist
index 024d63f..3b8cf74 100644
--- a/CodexBarHelper/app.zabrian.codexbar.helper.plist
+++ b/CodexBarHelper/Power/Daemon/CodexBarPowerHelper.Debug.plist
@@ -4,17 +4,17 @@
<dict>
<key>AssociatedBundleIdentifiers</key>
<array>
- <string>app.zabrian.codexbar.helper-manager</string>
+ <string>app.zabrian.codexbar.helper.power.manager.debug</string>
</array>
<key>BundleProgram</key>
- <string>Contents/Resources/CodexBarHelper</string>
+ <string>Contents/Helpers/CodexBarPowerHelper</string>
<key>KeepAlive</key>
<true/>
<key>Label</key>
- <string>app.zabrian.codexbar.helper</string>
+ <string>app.zabrian.codexbar.helper.power.debug</string>
<key>MachServices</key>
<dict>
- <key>app.zabrian.codexbar.helper</key>
+ <key>app.zabrian.codexbar.helper.power.debug</key>
<true/>
</dict>
<key>ProcessType</key>
diff --git a/CodexBarHelper/app.zabrian.codexbar.helper.debug.plist b/CodexBarHelper/Power/Daemon/CodexBarPowerHelper.plist
similarity index 68%
rename from CodexBarHelper/app.zabrian.codexbar.helper.debug.plist
rename to CodexBarHelper/Power/Daemon/CodexBarPowerHelper.plist
index f6220ab..2b5b84e 100644
--- a/CodexBarHelper/app.zabrian.codexbar.helper.debug.plist
+++ b/CodexBarHelper/Power/Daemon/CodexBarPowerHelper.plist
@@ -4,17 +4,17 @@
<dict>
<key>AssociatedBundleIdentifiers</key>
<array>
- <string>app.zabrian.codexbar.helper-manager.debug</string>
+ <string>app.zabrian.codexbar.helper.power.manager</string>
</array>
<key>BundleProgram</key>
- <string>Contents/Resources/CodexBarHelper</string>
+ <string>Contents/Helpers/CodexBarPowerHelper</string>
<key>KeepAlive</key>
<true/>
<key>Label</key>
- <string>app.zabrian.codexbar.helper.debug</string>
+ <string>app.zabrian.codexbar.helper.power</string>
<key>MachServices</key>
<dict>
- <key>app.zabrian.codexbar.helper.debug</key>
+ <key>app.zabrian.codexbar.helper.power</key>
<true/>
</dict>
<key>ProcessType</key>
diff --git a/CodexBarHelper/OwnershipStore.swift b/CodexBarHelper/Power/Daemon/OwnershipStore.swift
similarity index 92%
rename from CodexBarHelper/OwnershipStore.swift
rename to CodexBarHelper/Power/Daemon/OwnershipStore.swift
index 8aa415d..2505c98 100644
--- a/CodexBarHelper/OwnershipStore.swift
+++ b/CodexBarHelper/Power/Daemon/OwnershipStore.swift
@@ -73,7 +73,7 @@ struct OwnershipStore: OwnershipStoring {
"actual=\(fileTypeName(info.st_mode))",
"expected=directory"
)
- throw HelperError.insecureOwnershipDirectory(
+ throw PowerHelperError.insecureOwnershipDirectory(
"目录类型错误: \(details)"
)
}
@@ -82,7 +82,7 @@ struct OwnershipStore: OwnershipStoring {
"actual=\(info.st_uid)",
"expected=0"
)
- throw HelperError.insecureOwnershipDirectory(
+ throw PowerHelperError.insecureOwnershipDirectory(
"所有者错误: \(details)"
)
}
@@ -91,7 +91,7 @@ struct OwnershipStore: OwnershipStoring {
"actual=\(permissionString(info.st_mode))",
"forbidden=0022"
)
- throw HelperError.insecureOwnershipDirectory(
+ throw PowerHelperError.insecureOwnershipDirectory(
"目录权限错误: \(details)"
)
}
@@ -100,7 +100,7 @@ struct OwnershipStore: OwnershipStoring {
func writeOwnershipDataDurably(_ data: Data) throws {
let directoryURL = url.deletingLastPathComponent()
let temporaryURL = directoryURL.appending(
- path: ".helper-state.\(UUID().uuidString).tmp"
+ path: ".power-helper-state.\(UUID().uuidString).tmp"
)
var descriptor = open(
temporaryURL.path,
@@ -194,7 +194,7 @@ struct OwnershipStore: OwnershipStoring {
private func ownershipWriteError(
operation: String,
code: Int32 = errno
- ) -> HelperError {
+ ) -> PowerHelperError {
.ownershipWriteFailed(operation: operation, code: code)
}
@@ -215,7 +215,7 @@ struct OwnershipStore: OwnershipStoring {
if errno == ENOENT {
return nil
}
- throw HelperError.invalidOwnershipRecord(
+ throw PowerHelperError.invalidOwnershipRecord(
"读取属性失败: errno=\(errno)"
)
}
@@ -224,7 +224,7 @@ struct OwnershipStore: OwnershipStoring {
"actual=\(fileTypeName(info.st_mode))",
"expected=file"
)
- throw HelperError.invalidOwnershipRecord(
+ throw PowerHelperError.invalidOwnershipRecord(
"文件类型错误: \(details)"
)
}
@@ -233,7 +233,7 @@ struct OwnershipStore: OwnershipStoring {
"actual=\(info.st_uid)",
"expected=0"
)
- throw HelperError.invalidOwnershipRecord(
+ throw PowerHelperError.invalidOwnershipRecord(
"所有者错误: \(details)"
)
}
@@ -242,7 +242,7 @@ struct OwnershipStore: OwnershipStoring {
"actual=\(permissionString(info.st_mode))",
"forbidden=0022"
)
- throw HelperError.invalidOwnershipRecord(
+ throw PowerHelperError.invalidOwnershipRecord(
"文件权限错误: \(details)"
)
}
@@ -251,7 +251,7 @@ struct OwnershipStore: OwnershipStoring {
do {
data = try Data(contentsOf: url)
} catch {
- throw HelperError.invalidOwnershipRecord(
+ throw PowerHelperError.invalidOwnershipRecord(
"读取内容失败: detail=\(error.localizedDescription)"
)
}
@@ -262,7 +262,7 @@ struct OwnershipStore: OwnershipStoring {
do {
record = try decoder.decode(SleepOwnershipRecord.self, from: data)
} catch {
- throw HelperError.invalidOwnershipRecord(
+ throw PowerHelperError.invalidOwnershipRecord(
"解码失败: detail=\(error.localizedDescription)"
)
}
@@ -271,7 +271,7 @@ struct OwnershipStore: OwnershipStoring {
"actual=\(record.schema)",
"expected=1"
)
- throw HelperError.invalidOwnershipRecord(
+ throw PowerHelperError.invalidOwnershipRecord(
"版本错误: \(details)"
)
}
diff --git a/CodexBarHelper/Pmset.swift b/CodexBarHelper/Power/Daemon/Pmset.swift
similarity index 95%
rename from CodexBarHelper/Pmset.swift
rename to CodexBarHelper/Power/Daemon/Pmset.swift
index f3cb666..43d2569 100644
--- a/CodexBarHelper/Pmset.swift
+++ b/CodexBarHelper/Power/Daemon/Pmset.swift
@@ -7,7 +7,7 @@ struct PmsetResult {
let output: String
}
-struct HelperSleepOperations {
+struct PowerHelperSleepOperations {
var read: () -> (result: PmsetResult, value: Bool?)
var write: (Bool) -> PmsetResult
@@ -28,7 +28,7 @@ enum PmsetRunner {
return (result, parseSleepDisabled(from: result.output))
}
- /// 所有调用均由 helper 状态队列串行执行, 未退出的旧写入不能与新操作重叠
+ /// 所有调用均由 Power Helper 状态队列串行执行, 未退出的旧写入不能与新操作重叠
private static let unfinished = Mutex<Process?>(nil)
private static func run(arguments: [String]) -> PmsetResult {
@@ -63,7 +63,7 @@ enum PmsetRunner {
}
enum AutoResetWakeScheduler {
- static let owner = CodexBarHelperIPC.machServiceName + ".auto-reset"
+ static let owner = CodexBarPowerHelperIPC.serviceIdentifier + ".auto-reset"
static func replaceSchedule(with date: Date?) -> IOReturn {
let cancelResult = cancelOwnedEvents()
diff --git a/CodexBarHelper/HelperError.swift b/CodexBarHelper/Power/Daemon/PowerHelperError.swift
similarity index 94%
rename from CodexBarHelper/HelperError.swift
rename to CodexBarHelper/Power/Daemon/PowerHelperError.swift
index 914cd68..5311cc5 100644
--- a/CodexBarHelper/HelperError.swift
+++ b/CodexBarHelper/Power/Daemon/PowerHelperError.swift
@@ -1,6 +1,6 @@
import Foundation
-enum HelperError: LocalizedError {
+enum PowerHelperError: LocalizedError {
case insecureOwnershipDirectory(String)
case invalidOwnershipRecord(String)
case ownershipWriteFailed(operation: String, code: Int32)
diff --git a/CodexBarHelper/HelperRuntime.swift b/CodexBarHelper/Power/Daemon/PowerHelperRuntime.swift
similarity index 82%
rename from CodexBarHelper/HelperRuntime.swift
rename to CodexBarHelper/Power/Daemon/PowerHelperRuntime.swift
index 2951905..0c5f7e9 100644
--- a/CodexBarHelper/HelperRuntime.swift
+++ b/CodexBarHelper/Power/Daemon/PowerHelperRuntime.swift
@@ -6,9 +6,9 @@ import os
import Security
import Synchronization
-private let helperLog = Logger(
- subsystem: CodexBarHelperIPC.machServiceName,
- category: "helper"
+private let powerHelperLog = Logger(
+ subsystem: CodexBarPowerHelperIPC.serviceIdentifier,
+ category: "power-helper"
)
enum LogFields {
@@ -17,18 +17,18 @@ enum LogFields {
}
}
-private enum CodexBarHelperStorage {
+private enum CodexBarPowerHelperStorage {
static let ownershipURL: URL = {
guard let applicationSupportURL = FileManager.default.urls(
for: .applicationSupportDirectory,
in: .localDomainMask
).first else {
- helperLog.error("Helper 启动失败: reason=applicationSupportMissing")
+ powerHelperLog.error("Power Helper 启动失败: reason=applicationSupportMissing")
exit(EXIT_FAILURE)
}
return applicationSupportURL
.appending(path: "CodexBar", directoryHint: .isDirectory)
- .appending(path: "helper-state.json")
+ .appending(path: "power-helper-state.json")
}()
}
@@ -47,25 +47,25 @@ private struct ClientLease {
private enum SleepRestoreTrigger: String {
case appRequest
case connectionWatchdog
- case helperStartup
+ case powerHelperStartup
case ownershipCheck
- case helperTermination
+ case powerHelperTermination
}
private enum WakeScheduleCleanupTrigger: String {
case appRequest
case connectionClosed
- case helperStartup
+ case powerHelperStartup
case ownershipCheck
- case helperTermination
+ case powerHelperTermination
}
-private final class HelperSession: NSObject, CodexBarHelperProtocol,
+private final class PowerHelperSession: NSObject, CodexBarPowerHelperProtocol,
@unchecked Sendable {
let identifier = UUID()
- private weak var runtime: HelperRuntime?
+ private weak var runtime: PowerHelperRuntime?
- init(runtime: HelperRuntime) {
+ init(runtime: PowerHelperRuntime) {
self.runtime = runtime
}
@@ -132,15 +132,15 @@ private final class HelperSession: NSObject, CodexBarHelperProtocol,
}
}
-final class HelperRuntime: NSObject, NSXPCListenerDelegate, @unchecked Sendable {
+final class PowerHelperRuntime: NSObject, NSXPCListenerDelegate, @unchecked Sendable {
private struct Watchdog {
let token: UUID
let workItem: DispatchWorkItem
}
- private let queue = DispatchQueue(label: CodexBarHelperIPC.machServiceName + ".state")
+ private let queue = DispatchQueue(label: CodexBarPowerHelperIPC.serviceIdentifier + ".state")
private let ownershipStore: any OwnershipStoring
- private let sleepOperations: HelperSleepOperations
+ private let sleepOperations: PowerHelperSleepOperations
private var ownership = SleepOwnership.idle
private var transactionID = UUID()
private var lastCompletedUpdateIdentifier: String?
@@ -155,15 +155,15 @@ final class HelperRuntime: NSObject, NSXPCListenerDelegate, @unchecked Sendable
private var signalSources = [DispatchSourceSignal]()
private var listener: NSXPCListener?
- init(ownershipStore: (any OwnershipStoring)? = nil, sleepOperations: HelperSleepOperations = .system) {
- self.ownershipStore = ownershipStore ?? OwnershipStore(url: CodexBarHelperStorage.ownershipURL)
+ init(ownershipStore: (any OwnershipStoring)? = nil, sleepOperations: PowerHelperSleepOperations = .system) {
+ self.ownershipStore = ownershipStore ?? OwnershipStore(url: CodexBarPowerHelperStorage.ownershipURL)
self.sleepOperations = sleepOperations
super.init()
}
func run() {
guard geteuid() == 0 else {
- helperLog.error("Helper 启动失败: reason=notRoot")
+ powerHelperLog.error("Power Helper 启动失败: reason=notRoot")
exit(EXIT_FAILURE)
}
@@ -176,7 +176,7 @@ final class HelperRuntime: NSObject, NSXPCListenerDelegate, @unchecked Sendable
"path=\(directoryPath)",
"detail=\(error.localizedDescription)"
)
- helperLog.error("Helper 启动失败: \(details, privacy: .public)")
+ powerHelperLog.error("Power Helper 启动失败: \(details, privacy: .public)")
exit(EXIT_FAILURE)
}
@@ -193,11 +193,11 @@ final class HelperRuntime: NSObject, NSXPCListenerDelegate, @unchecked Sendable
"reason=listener",
"detail=\(error.localizedDescription)"
)
- helperLog.error("Helper 启动失败: \(details, privacy: .public)")
+ powerHelperLog.error("Power Helper 启动失败: \(details, privacy: .public)")
exit(EXIT_FAILURE)
}
- let listener = NSXPCListener(machServiceName: CodexBarHelperIPC.machServiceName)
+ let listener = NSXPCListener(machServiceName: CodexBarPowerHelperIPC.serviceIdentifier)
listener.setConnectionCodeSigningRequirement(clientCodeSigningRequirement)
listener.delegate = self
listener.resume()
@@ -306,7 +306,7 @@ final class HelperRuntime: NSObject, NSXPCListenerDelegate, @unchecked Sendable
return
}
- helperLog.notice("Helper 更新后已完成睡眠状态检查")
+ powerHelperLog.notice("Power Helper 更新后已完成睡眠状态检查")
reply(0)
}
}
@@ -367,7 +367,7 @@ final class HelperRuntime: NSObject, NSXPCListenerDelegate, @unchecked Sendable
"action=\(date == nil ? "cancel" : "schedule")",
"code=\(result)"
)
- helperLog.error("自动重置唤醒计划更新失败: \(details, privacy: .public)")
+ powerHelperLog.error("自动重置唤醒计划更新失败: \(details, privacy: .public)")
reply(result)
return
}
@@ -378,7 +378,7 @@ final class HelperRuntime: NSObject, NSXPCListenerDelegate, @unchecked Sendable
}
if let date {
let epoch = Int(date.timeIntervalSince1970)
- helperLog.notice("自动重置唤醒计划已设置: epoch=\(epoch)")
+ powerHelperLog.notice("自动重置唤醒计划已设置: epoch=\(epoch)")
}
reply(kIOReturnSuccess)
}
@@ -388,10 +388,10 @@ final class HelperRuntime: NSObject, NSXPCListenerDelegate, @unchecked Sendable
_: NSXPCListener,
shouldAcceptNewConnection newConnection: NSXPCConnection
) -> Bool {
- let session = HelperSession(runtime: self)
+ let session = PowerHelperSession(runtime: self)
let identifier = session.identifier
newConnection.exportedInterface = NSXPCInterface(
- with: CodexBarHelperProtocol.self
+ with: CodexBarPowerHelperProtocol.self
)
newConnection.exportedObject = session
@@ -457,12 +457,12 @@ final class HelperRuntime: NSObject, NSXPCListenerDelegate, @unchecked Sendable
"code=\(result)",
"remaining=\(AutoResetWakeScheduler.ownedEventCount)"
)
- helperLog.error("自动重置唤醒计划取消失败: \(details, privacy: .public)")
+ powerHelperLog.error("自动重置唤醒计划取消失败: \(details, privacy: .public)")
return result
}
isAutoResetWakeCleanupPending = false
- helperLog.notice(
+ powerHelperLog.notice(
"自动重置唤醒计划已取消: reason=\(trigger.rawValue, privacy: .public)"
)
return kIOReturnSuccess
@@ -493,7 +493,7 @@ final class HelperRuntime: NSObject, NSXPCListenerDelegate, @unchecked Sendable
}
watchdogs[clientIdentifier] = Watchdog(token: token, workItem: workItem)
queue.asyncAfter(
- deadline: .now() + CodexBarHelperIPC.watchdogGraceSeconds,
+ deadline: .now() + CodexBarPowerHelperIPC.watchdogGraceSeconds,
execute: workItem
)
}
@@ -512,35 +512,9 @@ final class HelperRuntime: NSObject, NSXPCListenerDelegate, @unchecked Sendable
}
}
- if ownership == .owned {
- guard validateOrRepairOwnedRecord() else {
- return recoverFromOwnedRecordFailure()
- }
-
- let current = readCurrentSleepDisabled()
- guard current.result.exitCode == 0, let sleepDisabled = current.value else {
- logPmsetReadFailure(current.result)
- return SleepOperationResult(
- exitCode: normalizedFailureCode(current.result.exitCode),
- source: .codexBar,
- sleepDisabled: false
- )
- }
-
- if !sleepDisabled {
- let result = setAndVerifySleepDisabled(true)
- guard result.exitCode == 0 else {
- return SleepOperationResult(
- exitCode: result.exitCode,
- source: .codexBar,
- sleepDisabled: result.value ?? false
- )
- }
- guard validateOrRepairOwnedRecord() else {
- return recoverFromOwnedRecordFailure()
- }
- }
- return SleepOperationResult(exitCode: 0, source: .codexBar, sleepDisabled: true)
+ let wasOwned = ownership == .owned
+ if wasOwned, !validateOrRepairOwnedRecord() {
+ return recoverFromOwnedRecordFailure()
}
let current = readCurrentSleepDisabled()
@@ -548,23 +522,25 @@ final class HelperRuntime: NSObject, NSXPCListenerDelegate, @unchecked Sendable
logPmsetReadFailure(current.result)
return SleepOperationResult(
exitCode: normalizedFailureCode(current.result.exitCode),
- source: .none,
+ source: wasOwned ? .codexBar : .none,
sleepDisabled: false
)
}
guard !sleepDisabled else {
- if logsExternalState {
- helperLog.notice("系统睡眠已由其他来源关闭")
+ if !wasOwned, logsExternalState {
+ powerHelperLog.notice("系统睡眠已由其他来源关闭")
}
- return SleepOperationResult(exitCode: 0, source: .external, sleepDisabled: true)
+ return SleepOperationResult(exitCode: 0, source: wasOwned ? .codexBar : .external, sleepDisabled: true)
}
- do {
- try persistOwnership(.owned)
- } catch {
- logOwnershipWriteFailure(error)
- return SleepOperationResult(exitCode: -1, source: .none, sleepDisabled: false)
+ if !wasOwned {
+ do {
+ try persistOwnership(.owned)
+ } catch {
+ logOwnershipWriteFailure(error)
+ return SleepOperationResult(exitCode: -1, source: .none, sleepDisabled: false)
+ }
}
let result = setAndVerifySleepDisabled(true)
@@ -579,7 +555,9 @@ final class HelperRuntime: NSObject, NSXPCListenerDelegate, @unchecked Sendable
return recoverFromOwnedRecordFailure()
}
- helperLog.notice("系统睡眠已由 CodexBar 关闭")
+ if !wasOwned {
+ powerHelperLog.notice("系统睡眠已由 CodexBar 关闭")
+ }
return SleepOperationResult(exitCode: 0, source: .codexBar, sleepDisabled: true)
}
@@ -617,7 +595,7 @@ final class HelperRuntime: NSObject, NSXPCListenerDelegate, @unchecked Sendable
"trigger=\(trigger.rawValue)",
"exit=\(result.exitCode)"
)
- helperLog.error("系统睡眠恢复失败: \(details, privacy: .public)")
+ powerHelperLog.error("系统睡眠恢复失败: \(details, privacy: .public)")
return SleepOperationResult(
exitCode: result.exitCode,
source: .codexBar,
@@ -636,7 +614,7 @@ final class HelperRuntime: NSObject, NSXPCListenerDelegate, @unchecked Sendable
"trigger=\(trigger.rawValue)",
"sleepDisabled=0"
)
- helperLog.notice("系统睡眠已恢复: \(details, privacy: .public)")
+ powerHelperLog.notice("系统睡眠已恢复: \(details, privacy: .public)")
return SleepOperationResult(exitCode: 0, source: .codexBar, sleepDisabled: false)
}
@@ -650,7 +628,7 @@ final class HelperRuntime: NSObject, NSXPCListenerDelegate, @unchecked Sendable
"exit=\(writeResult.exitCode)",
"detail=\(writeResult.output)"
)
- helperLog.error("pmset 写入失败: \(details, privacy: .public)")
+ powerHelperLog.error("pmset 写入失败: \(details, privacy: .public)")
return (writeResult.exitCode, nil)
}
@@ -664,7 +642,7 @@ final class HelperRuntime: NSObject, NSXPCListenerDelegate, @unchecked Sendable
"target=\(disabled ? 1 : 0)",
"actual=\(value ? 1 : 0)"
)
- helperLog.error("pmset 写入校验失败: \(details, privacy: .public)")
+ powerHelperLog.error("pmset 写入校验失败: \(details, privacy: .public)")
return (-1, value)
}
return (0, value)
@@ -689,10 +667,10 @@ final class HelperRuntime: NSObject, NSXPCListenerDelegate, @unchecked Sendable
return true
}
- helperLog.error("睡眠所有权记录与运行状态不一致: action=repair")
+ powerHelperLog.error("睡眠所有权记录与运行状态不一致: action=repair")
do {
try persistOwnership(.owned)
- helperLog.notice("睡眠所有权记录已修复")
+ powerHelperLog.notice("睡眠所有权记录已修复")
return true
} catch {
logOwnershipWriteFailure(error)
@@ -740,7 +718,7 @@ final class HelperRuntime: NSObject, NSXPCListenerDelegate, @unchecked Sendable
"exit=\(result.exitCode)",
"detail=\(result.output)"
)
- helperLog.error("pmset 读取失败: \(details, privacy: .public)")
+ powerHelperLog.error("pmset 读取失败: \(details, privacy: .public)")
}
// MARK: - 异常恢复
@@ -751,7 +729,7 @@ final class HelperRuntime: NSObject, NSXPCListenerDelegate, @unchecked Sendable
case .absent:
do {
try persistOwnership(.idle)
- helperLog.notice("Helper 已启动: ownership=idle")
+ powerHelperLog.notice("Power Helper 已启动: ownership=idle")
} catch {
logOwnershipWriteFailure(error)
exit(EXIT_FAILURE)
@@ -760,11 +738,11 @@ final class HelperRuntime: NSObject, NSXPCListenerDelegate, @unchecked Sendable
ownership = record.state
transactionID = record.transaction
lastCompletedUpdateIdentifier = record.identifier
- helperLog.notice(
- "Helper 已启动: ownership=\(record.state.rawValue, privacy: .public)"
+ powerHelperLog.notice(
+ "Power Helper 已启动: ownership=\(record.state.rawValue, privacy: .public)"
)
if record.state.needsRestore {
- _ = restoreOwnedSleep(trigger: .helperStartup)
+ _ = restoreOwnedSleep(trigger: .powerHelperStartup)
}
case let .unreadable(error):
// 损坏记录无法证明所有权, 启动时按最安全的默认值 0 收敛
@@ -772,9 +750,9 @@ final class HelperRuntime: NSObject, NSXPCListenerDelegate, @unchecked Sendable
"detail=\(error.localizedDescription)",
"action=forceRestore"
)
- helperLog.error("睡眠所有权记录无效: \(details, privacy: .public)")
+ powerHelperLog.error("睡眠所有权记录无效: \(details, privacy: .public)")
ownership = .restoring
- _ = restoreOwnedSleep(trigger: .helperStartup)
+ _ = restoreOwnedSleep(trigger: .powerHelperStartup)
}
if lastKnownSleepDisabled == nil {
@@ -798,8 +776,8 @@ final class HelperRuntime: NSObject, NSXPCListenerDelegate, @unchecked Sendable
}
lastResult = AutoResetWakeScheduler.replaceSchedule(with: nil)
if lastResult == kIOReturnSuccess {
- helperLog.notice(
- "自动重置遗留唤醒计划已清理: reason=helperStartup count=\(initialEventCount)"
+ powerHelperLog.notice(
+ "自动重置遗留唤醒计划已清理: reason=powerHelperStartup count=\(initialEventCount)"
)
return
}
@@ -807,11 +785,11 @@ final class HelperRuntime: NSObject, NSXPCListenerDelegate, @unchecked Sendable
isAutoResetWakeCleanupPending = true
let details = LogFields.joined(
- "reason=\(WakeScheduleCleanupTrigger.helperStartup.rawValue)",
+ "reason=\(WakeScheduleCleanupTrigger.powerHelperStartup.rawValue)",
"code=\(lastResult)",
"remaining=\(AutoResetWakeScheduler.ownedEventCount)"
)
- helperLog.error("自动重置遗留唤醒计划清理失败: \(details, privacy: .public)")
+ powerHelperLog.error("自动重置遗留唤醒计划清理失败: \(details, privacy: .public)")
}
private func installOwnershipTimer() {
@@ -842,13 +820,13 @@ final class HelperRuntime: NSObject, NSXPCListenerDelegate, @unchecked Sendable
}
let interval: TimeInterval = if isAutoResetWakeCleanupPending {
- CodexBarHelperIPC.ownedCheckIntervalSeconds
+ CodexBarPowerHelperIPC.ownedCheckIntervalSeconds
} else if activeClientCount == 0 {
- CodexBarHelperIPC.recoveryCheckIntervalSeconds
+ CodexBarPowerHelperIPC.recoveryCheckIntervalSeconds
} else if ownership.needsRestore {
- CodexBarHelperIPC.ownedCheckIntervalSeconds
+ CodexBarPowerHelperIPC.ownedCheckIntervalSeconds
} else {
- CodexBarHelperIPC.externalCheckIntervalSeconds
+ CodexBarPowerHelperIPC.externalCheckIntervalSeconds
}
guard force || interval != scheduledOwnershipCheckInterval else {
return
@@ -858,7 +836,7 @@ final class HelperRuntime: NSObject, NSXPCListenerDelegate, @unchecked Sendable
ownershipTimer.schedule(
deadline: .now() + interval,
repeating: interval,
- leeway: .seconds(Int(CodexBarHelperIPC.checkLeewaySeconds))
+ leeway: .seconds(Int(CodexBarPowerHelperIPC.checkLeewaySeconds))
)
}
@@ -871,10 +849,10 @@ final class HelperRuntime: NSObject, NSXPCListenerDelegate, @unchecked Sendable
exit(EXIT_SUCCESS)
}
if ownership.needsRestore {
- _ = restoreOwnedSleep(trigger: .helperTermination)
+ _ = restoreOwnedSleep(trigger: .powerHelperTermination)
}
autoResetWakeConnectionIdentifier = nil
- _ = cancelAutoResetWakeSchedule(trigger: .helperTermination)
+ _ = cancelAutoResetWakeSchedule(trigger: .powerHelperTermination)
exit(EXIT_SUCCESS)
}
source.resume()
@@ -906,7 +884,7 @@ final class HelperRuntime: NSObject, NSXPCListenerDelegate, @unchecked Sendable
savedRecord.state == state,
savedRecord.transaction == transactionID,
savedRecord.identifier == lastCompletedUpdateIdentifier else {
- throw HelperError.invalidOwnershipRecord("写入后校验失败")
+ throw PowerHelperError.invalidOwnershipRecord("写入后校验失败")
}
ownership = state
}
@@ -917,7 +895,7 @@ final class HelperRuntime: NSObject, NSXPCListenerDelegate, @unchecked Sendable
"path=\(path)",
"detail=\(error.localizedDescription)"
)
- helperLog.error("睡眠所有权记录写入失败: \(details, privacy: .public)")
+ powerHelperLog.error("睡眠所有权记录写入失败: \(details, privacy: .public)")
}
private static func isValidUpdateIdentifier(_ identifier: String) -> Bool {
@@ -935,7 +913,7 @@ final class HelperRuntime: NSObject, NSXPCListenerDelegate, @unchecked Sendable
"Operation=SecCodeCopySelf",
"Status=\(status)"
)
- throw HelperError.codeSigningValidationFailed(
+ throw PowerHelperError.codeSigningValidationFailed(
"读取运行签名失败: \(details)"
)
}
@@ -947,7 +925,7 @@ final class HelperRuntime: NSObject, NSXPCListenerDelegate, @unchecked Sendable
"Operation=SecCodeCopyStaticCode",
"Status=\(status)"
)
- throw HelperError.codeSigningValidationFailed(
+ throw PowerHelperError.codeSigningValidationFailed(
"读取静态签名失败: \(details)"
)
}
@@ -963,46 +941,46 @@ final class HelperRuntime: NSObject, NSXPCListenerDelegate, @unchecked Sendable
"Operation=SecCodeCopySigningInformation",
"Status=\(status)"
)
- throw HelperError.codeSigningValidationFailed(
+ throw PowerHelperError.codeSigningValidationFailed(
"读取签名信息失败: \(details)"
)
}
let values = signingInformation as NSDictionary
guard let teamIdentifier = values[kSecCodeInfoTeamIdentifier] as? String else {
- throw HelperError.codeSigningValidationFailed("Team ID 缺失")
+ throw PowerHelperError.codeSigningValidationFailed("Team ID 缺失")
}
- guard let helperIdentifier = values[kSecCodeInfoIdentifier] as? String else {
- throw HelperError.codeSigningValidationFailed("Helper 标识符缺失")
+ guard let powerHelperIdentifier = values[kSecCodeInfoIdentifier] as? String else {
+ throw PowerHelperError.codeSigningValidationFailed("Power Helper 标识符缺失")
}
- guard helperIdentifier == CodexBarHelperIPC.machServiceName else {
+ guard powerHelperIdentifier == CodexBarPowerHelperIPC.serviceIdentifier else {
let details = LogFields.joined(
- "actual=\(helperIdentifier)",
- "expected=\(CodexBarHelperIPC.machServiceName)"
+ "actual=\(powerHelperIdentifier)",
+ "expected=\(CodexBarPowerHelperIPC.serviceIdentifier)"
)
- throw HelperError.codeSigningValidationFailed(
- "Helper 标识符错误: \(details)"
+ throw PowerHelperError.codeSigningValidationFailed(
+ "Power Helper 标识符错误: \(details)"
)
}
- let clientIdentifier = CodexBarHelperIPC.appBundleIdentifier
+ let clientIdentifier = CodexBarPowerHelperIPC.clientAppBundleIdentifier
let identifierCharacters = CharacterSet.alphanumerics.union(
CharacterSet(charactersIn: ".-")
)
guard !teamIdentifier.isEmpty else {
- throw HelperError.codeSigningValidationFailed("Team ID 为空")
+ throw PowerHelperError.codeSigningValidationFailed("Team ID 为空")
}
guard teamIdentifier.unicodeScalars.allSatisfy(CharacterSet.alphanumerics.contains) else {
- throw HelperError.codeSigningValidationFailed(
+ throw PowerHelperError.codeSigningValidationFailed(
"Team ID 格式错误: \(teamIdentifier)"
)
}
guard !clientIdentifier.isEmpty else {
- throw HelperError.codeSigningValidationFailed("客户端标识符为空")
+ throw PowerHelperError.codeSigningValidationFailed("客户端标识符为空")
}
guard clientIdentifier.unicodeScalars.allSatisfy(identifierCharacters.contains) else {
- throw HelperError.codeSigningValidationFailed(
+ throw PowerHelperError.codeSigningValidationFailed(
"客户端标识符格式错误: \(clientIdentifier)"
)
}
diff --git a/CodexBarHelper/main.swift b/CodexBarHelper/Power/Daemon/main.swift
similarity index 52%
rename from CodexBarHelper/main.swift
rename to CodexBarHelper/Power/Daemon/main.swift
index 6bbba80..3ae965c 100644
--- a/CodexBarHelper/main.swift
+++ b/CodexBarHelper/Power/Daemon/main.swift
@@ -1,5 +1,5 @@
import Foundation
-private let runtime = HelperRuntime()
+private let runtime = PowerHelperRuntime()
runtime.run()
dispatchMain()
diff --git a/CodexBarHelperManager/ManagerMain.swift b/CodexBarHelper/Power/Manager/PowerHelperManagerMain.swift
similarity index 75%
rename from CodexBarHelperManager/ManagerMain.swift
rename to CodexBarHelper/Power/Manager/PowerHelperManagerMain.swift
index ba0d9e2..20a90c1 100644
--- a/CodexBarHelperManager/ManagerMain.swift
+++ b/CodexBarHelper/Power/Manager/PowerHelperManagerMain.swift
@@ -2,14 +2,14 @@ import Foundation
import ServiceManagement
@main
-enum HelperManagerMain {
+enum PowerHelperManagerMain {
static func main() async {
let arguments = CommandLine.arguments
guard arguments.count == 2,
- let command = HelperManagement.Command(rawValue: arguments[1]) else {
+ let command = PowerHelperManagement.Command(rawValue: arguments[1]) else {
return
}
- let service = SMAppService.daemon(plistName: CodexBarHelperIPC.daemonPlistName)
+ let service = SMAppService.daemon(plistName: CodexBarPowerHelperIPC.daemonPlistName)
var failure: NSError?
do {
switch command {
@@ -23,7 +23,7 @@ enum HelperManagerMain {
} catch {
failure = error as NSError
}
- let reply = HelperManagement.Reply(
+ let reply = PowerHelperManagement.Reply(
status: service.status.rawValue,
errorDomain: failure?.domain,
errorCode: failure?.code
diff --git a/Resources/CodexBar Helper.icon/Assets/CodexBar Helper.png b/CodexBarHelper/Power/Manager/Resources/AppIcon.icon/Assets/CodexBar Power Helper.png
similarity index 100%
rename from Resources/CodexBar Helper.icon/Assets/CodexBar Helper.png
rename to CodexBarHelper/Power/Manager/Resources/AppIcon.icon/Assets/CodexBar Power Helper.png
diff --git a/Resources/CodexBar Helper.icon/icon.json b/CodexBarHelper/Power/Manager/Resources/AppIcon.icon/icon.json
similarity index 77%
rename from Resources/CodexBar Helper.icon/icon.json
rename to CodexBarHelper/Power/Manager/Resources/AppIcon.icon/icon.json
index f1b3634..bf07644 100644
--- a/Resources/CodexBar Helper.icon/icon.json
+++ b/CodexBarHelper/Power/Manager/Resources/AppIcon.icon/icon.json
@@ -4,8 +4,8 @@
{
"layers" : [
{
- "image-name" : "CodexBar Helper.png",
- "name" : "CodexBar Helper"
+ "image-name" : "CodexBar Power Helper.png",
+ "name" : "CodexBar Power Helper"
}
],
"shadow" : {
diff --git a/Shared/CodexBarHelperXPC.swift b/CodexBarHelper/Power/Shared/CodexBarPowerHelperXPC.swift
similarity index 65%
rename from Shared/CodexBarHelperXPC.swift
rename to CodexBarHelper/Power/Shared/CodexBarPowerHelperXPC.swift
index e84bb25..f376fee 100644
--- a/Shared/CodexBarHelperXPC.swift
+++ b/CodexBarHelper/Power/Shared/CodexBarPowerHelperXPC.swift
@@ -1,21 +1,22 @@
import Foundation
-nonisolated enum CodexBarHelperIPC {
+nonisolated enum CodexBarPowerHelperIPC {
#if DEBUG
- static let appBundleIdentifier = "app.zabrian.codexbar.debug"
- static let machServiceName = "app.zabrian.codexbar.helper.debug"
+ static let clientAppBundleIdentifier = "app.zabrian.codexbar.debug"
+ static let serviceIdentifier = "app.zabrian.codexbar.helper.power.debug"
+ static let daemonPlistName = "CodexBarPowerHelper.Debug.plist"
#else
- static let appBundleIdentifier = "app.zabrian.codexbar"
- static let machServiceName = "app.zabrian.codexbar.helper"
+ static let clientAppBundleIdentifier = "app.zabrian.codexbar"
+ static let serviceIdentifier = "app.zabrian.codexbar.helper.power"
+ static let daemonPlistName = "CodexBarPowerHelper.plist"
#endif
- static let daemonPlistName = machServiceName + ".plist"
static let watchdogGraceSeconds: TimeInterval = 15
static let externalCheckIntervalSeconds: TimeInterval = 5
static let ownedCheckIntervalSeconds: TimeInterval = 5
static let recoveryCheckIntervalSeconds: TimeInterval = 60
static let checkLeewaySeconds: TimeInterval = 1
- /// App 侧等回复的上限, 与 watchdog 宽限是一对: 必须更小, 这样 App 先放手 helper 再自行兜底
- /// helper 冷启动加一次 pmset 通常一秒内完成, 留这么宽只为排除偶发的调度抖动
+ /// App 侧等回复的上限, 与 watchdog 宽限是一对: 必须更小, 这样 App 先放手 Power Helper 再自行兜底
+ /// Power Helper 冷启动加一次 pmset 通常一秒内完成, 留这么宽只为排除偶发的调度抖动
static let requestTimeoutSeconds: TimeInterval = 10
}
@@ -31,7 +32,7 @@ nonisolated enum CodexBarSleepOwnershipState: Int, Sendable {
case restoring
}
-@objc nonisolated protocol CodexBarHelperProtocol: AnyObject {
+@objc nonisolated protocol CodexBarPowerHelperProtocol: AnyObject {
/// reply 依次返回 pmset 退出码, 本轮防睡眠来源与操作后实测的 SleepDisabled
func setSleepPreventionRequested(
_ requested: Bool,
@@ -45,7 +46,7 @@ nonisolated enum CodexBarSleepOwnershipState: Int, Sendable {
reply: @escaping @Sendable (Int32, Int, Int, Bool) -> Void
)
- /// helper 更新后按租约和所有权核对, 同一指纹只完成一次
+ /// Power Helper 更新后按租约和所有权核对, 同一指纹只完成一次
func resetSleepAfterUpdate(
_ updateIdentifier: String,
reply: @escaping @Sendable (Int32) -> Void
diff --git a/Shared/HelperManagement.swift b/CodexBarHelper/Power/Shared/PowerHelperManagement.swift
similarity index 66%
rename from Shared/HelperManagement.swift
rename to CodexBarHelper/Power/Shared/PowerHelperManagement.swift
index 558603c..0ec109b 100644
--- a/Shared/HelperManagement.swift
+++ b/CodexBarHelper/Power/Shared/PowerHelperManagement.swift
@@ -1,13 +1,13 @@
import Foundation
-nonisolated enum HelperManagement {
- static let executableName = "CodexBarHelperManager"
+nonisolated enum PowerHelperManagement {
+ static let executableName = "CodexBarPowerHelperManager"
#if DEBUG
- static let bundleName = "CodexBar Helper Debug.app"
- static let bundleIdentifier = "app.zabrian.codexbar.helper-manager.debug"
+ static let bundleName = "CodexBar Power Helper Debug.app"
+ static let bundleIdentifier = "app.zabrian.codexbar.helper.power.manager.debug"
#else
- static let bundleName = "CodexBar Helper.app"
- static let bundleIdentifier = "app.zabrian.codexbar.helper-manager"
+ static let bundleName = "CodexBar Power Helper.app"
+ static let bundleIdentifier = "app.zabrian.codexbar.helper.power.manager"
#endif
enum Command: String, Sendable {
diff --git a/CodexBarHelperTests/HelperUpdateTests.swift b/CodexBarHelperTests/HelperUpdateTests.swift
deleted file mode 100644
index 4c093bf..0000000
--- a/CodexBarHelperTests/HelperUpdateTests.swift
+++ /dev/null
@@ -1,167 +0,0 @@
-import Foundation
-import Synchronization
-import Testing
-
-@Suite(.timeLimit(.minutes(1)))
-struct HelperUpdateTests {
- @Test func updatePreservesExternalSleepSetting() async throws {
- let fixture = try Fixture(disabled: true)
- #expect(await fixture.update() == 0)
- #expect(fixture.system.values.withLock { $0.writes } == [])
- #expect(fixture.store.record()?.state == .idle)
- #expect(fixture.store.record()?.identifier == fixture.updateID)
- }
-
- @Test func updateKeepsLiveLeaseAndReleaseStillRestoresSleep() async throws {
- let fixture = try Fixture(disabled: false)
- #expect(await fixture.request(true, generation: 1) == 0)
- #expect(fixture.system.values.withLock { $0.disabled })
- #expect(await fixture.update() == 0)
- #expect(fixture.store.record()?.state == .owned)
- #expect(fixture.system.values.withLock { $0.writes } == [true])
- #expect(await fixture.request(false, generation: 2) == 0)
- #expect(fixture.system.values.withLock { $0.writes } == [true, false])
- #expect(fixture.store.record()?.state == .idle)
- }
-
- @Test func updateRetriesUnfinishedOwnedRecovery() async throws {
- let fixture = try Fixture(disabled: true, ownership: .owned, failWrite: true)
- #expect(fixture.store.record()?.state == .restoring)
- #expect(await fixture.update() != 0)
- #expect(fixture.store.record()?.identifier == nil)
- fixture.system.values.withLock { $0.failWrite = false }
- #expect(await fixture.update() == 0)
- #expect(!fixture.system.values.withLock { $0.disabled })
- #expect(fixture.store.record()?.state == .idle)
- #expect(fixture.store.record()?.identifier == fixture.updateID)
- }
-
- @Test func failedPersistenceDoesNotConsumeUpdateIdentifier() async throws {
- let fixture = try Fixture(disabled: true)
- fixture.store.values.withLock { $0.failWrite = true }
- #expect(await fixture.update() != 0)
- #expect(fixture.store.record()?.identifier == nil)
- fixture.store.values.withLock { $0.failWrite = false }
- #expect(await fixture.update() == 0)
- let writes = fixture.store.values.withLock { $0.writes }
- #expect(await fixture.update() == 0)
- #expect(fixture.store.values.withLock { $0.writes } == writes)
- #expect(fixture.system.values.withLock { $0.writes }.isEmpty)
- }
-
- @Test func failedReadCannotCompleteUpdate() async throws {
- let fixture = try Fixture(disabled: true)
- fixture.system.values.withLock { $0.failRead = true }
- #expect(await fixture.update() != 0)
- #expect(fixture.store.record()?.identifier == nil)
- fixture.system.values.withLock { $0.failRead = false }
- #expect(await fixture.update() == 0)
- #expect(fixture.system.values.withLock { $0.writes }.isEmpty)
- }
-}
-
-private struct Fixture {
- let store: MemoryOwnership
- let system: FakeSleepSystem
- let runtime: HelperRuntime
- let session: any CodexBarHelperProtocol
- let connection: TestConnection
- let clientID = UUID().uuidString
- let updateID = String(repeating: "a", count: 64)
-
- init(disabled: Bool, ownership: SleepOwnership = .idle, failWrite: Bool = false) throws {
- store = try MemoryOwnership(state: ownership)
- system = FakeSleepSystem(disabled: disabled, failWrite: failWrite)
- runtime = HelperRuntime(ownershipStore: store, sleepOperations: system.operations)
- runtime.recoverOwnershipAtStartup()
- connection = TestConnection()
- precondition(runtime.listener(NSXPCListener.anonymous(), shouldAcceptNewConnection: connection))
- session = try #require(connection.exportedObject as? any CodexBarHelperProtocol)
- }
-
- func update() async -> Int32 {
- await withCheckedContinuation { continuation in
- session.resetSleepAfterUpdate(updateID) { continuation.resume(returning: $0) }
- }
- }
-
- func request(_ requested: Bool, generation: UInt64) async -> Int32 {
- await withCheckedContinuation { continuation in
- session.setSleepPreventionRequested(requested, clientSessionID: clientID, generation: generation) { code, _, _ in
- continuation.resume(returning: code)
- }
- }
- }
-}
-
-private final class TestConnection: NSXPCConnection, @unchecked Sendable {
- override func resume() {}
-}
-
-private final class MemoryOwnership: OwnershipStoring, Sendable {
- struct State: Sendable {
- var data: Data
- var failWrite = false
- var writes = 0
- }
-
- let url = URL(fileURLWithPath: "/unused-helper-test-state")
- let values: Mutex<State>
-
- init(state: SleepOwnership) throws {
- let record = SleepOwnershipRecord(schema: 1, state: state, transaction: UUID(), identifier: nil, updated: Date())
- let encoder = JSONEncoder()
- encoder.dateEncodingStrategy = .iso8601
- values = try Mutex(State(data: encoder.encode(record)))
- }
-
- func ensureOwnershipDirectory() throws {}
- func writeOwnershipDataDurably(_ data: Data) throws {
- try values.withLock {
- if $0.failWrite {
- throw CocoaError(.fileWriteUnknown)
- }
- $0.data = data
- $0.writes += 1
- }
- }
-
- func record() -> SleepOwnershipRecord? {
- let decoder = JSONDecoder()
- decoder.dateDecodingStrategy = .iso8601
- return try? decoder.decode(SleepOwnershipRecord.self, from: values.withLock { $0.data })
- }
-
- func ownershipRecordState() -> OwnershipRecordState {
- record().map(OwnershipRecordState.present) ?? .absent
- }
-}
-
-private final class FakeSleepSystem: Sendable {
- struct State: Sendable {
- var disabled: Bool
- var failWrite: Bool
- var failRead = false
- var writes: [Bool] = []
- }
-
- let values: Mutex<State>
- init(disabled: Bool, failWrite: Bool) {
- values = Mutex(State(disabled: disabled, failWrite: failWrite))
- }
-
- var operations: HelperSleepOperations {
- HelperSleepOperations(read: { [self] in
- values.withLock { (PmsetResult(exitCode: $0.failRead ? -1 : 0, output: ""), $0.failRead ? nil : $0.disabled) }
- }, write: { [self] disabled in
- values.withLock {
- if $0.failWrite {
- return PmsetResult(exitCode: -1, output: "test failure")
- }
- $0.disabled = disabled
- $0.writes.append(disabled)
- return PmsetResult(exitCode: 0, output: "")
- }
- })
- }
-}
diff --git a/Scripts/cleanup.swift b/Scripts/cleanup.swift
index 0bc00eb..f5a4991 100755
--- a/Scripts/cleanup.swift
+++ b/Scripts/cleanup.swift
@@ -7,7 +7,7 @@ import IOKit
import IOKit.pwr_mgt
import ServiceManagement
-@objc private protocol CleanupHelperProtocol: AnyObject {
+@objc private protocol CleanupPowerHelperProtocol: AnyObject {
func setAutoResetWakeSchedule(
_ unixTimestamp: TimeInterval,
reply: @escaping @Sendable (Int32) -> Void
@@ -45,9 +45,9 @@ private enum CleanupBuildConfiguration: String, CaseIterable {
var managerBundleName: String {
switch self {
case .release:
- "CodexBar Helper.app"
+ "CodexBar Power Helper.app"
case .debug:
- "CodexBar Helper Debug.app"
+ "CodexBar Power Helper Debug.app"
}
}
@@ -67,15 +67,20 @@ private struct CleanupTarget {
let buildConfiguration: CleanupBuildConfiguration
var plistName: String {
- serviceLabel + ".plist"
+ switch buildConfiguration {
+ case .release:
+ "CodexBarPowerHelper.plist"
+ case .debug:
+ "CodexBarPowerHelper.Debug.plist"
+ }
}
- var serviceLabel: String {
+ var serviceIdentifier: String {
switch buildConfiguration {
case .release:
- "app.zabrian.codexbar.helper"
+ "app.zabrian.codexbar.helper.power"
case .debug:
- "app.zabrian.codexbar.helper.debug"
+ "app.zabrian.codexbar.helper.power.debug"
}
}
}
@@ -85,7 +90,7 @@ private struct CommandOutput {
let text: String
}
-private struct HelperManagerReply: Decodable {
+private struct PowerHelperManagerReply: Decodable {
let status: Int
let errorDomain: String?
let errorCode: Int?
@@ -194,12 +199,12 @@ private final class KeepAliveCleanupCommand {
仅注销 CodexBar 的 Release 和 Debug KeepAlive LaunchDaemon
Options:
- --release 只移除 Release Helper
- --debug 只移除 Debug Helper
+ --release 只移除 Release Power Helper
+ --debug 只移除 Debug Power Helper
--check 只检查目标
-h, --help 显示帮助
- 仅支持 Contents/Helpers 中的 Helper 管理 App
+ 仅支持 Contents/Helpers 中的 Power Helper 管理 App
不指定 --release 或 --debug 时同时处理两个目标
实际清理前请先退出待清理的 CodexBar 实例
"""
@@ -314,11 +319,11 @@ private final class KeepAliveCleanupCommand {
isCheckOnly: Bool
) throws {
let managerURL = target.appURL.appending(path: "Contents/Helpers/\(target.buildConfiguration.managerBundleName)")
- let managerExecutableURL = managerURL.appending(path: "Contents/MacOS/CodexBarHelperManager")
+ let managerExecutableURL = managerURL.appending(path: "Contents/MacOS/CodexBarPowerHelperManager")
let daemonPlistURL = managerURL.appending(path: "Contents/Library/LaunchDaemons/\(target.plistName)")
guard fileManager.isExecutableFile(atPath: managerExecutableURL.path),
fileManager.fileExists(atPath: daemonPlistURL.path) else {
- throw CleanupError.message("Helper 管理 App 缺失或结构无效, path=\(managerURL.path)")
+ throw CleanupError.message("Power Helper 管理 App 缺失或结构无效, path=\(managerURL.path)")
}
let teamIdentifier = try signingTeamIdentifier(for: target.appURL)
@@ -327,7 +332,7 @@ private final class KeepAliveCleanupCommand {
throw CleanupError.codeSigningValidationFailed("管理 App 与主 App 的 Team ID 不匹配")
}
- // 清理进程必须使用主 App 的签名身份, 才能通过 Helper 的 XPC 校验
+ // 清理进程必须使用主 App 的签名身份, 才能通过 Power Helper 的 XPC 校验
let cleanupAppURL = temporaryRoot
.appending(path: "\(target.bundleIdentifier).app", directoryHint: .isDirectory)
let contentsURL = cleanupAppURL.appending(path: "Contents", directoryHint: .isDirectory)
@@ -372,7 +377,7 @@ private final class KeepAliveCleanupCommand {
try runChecked(
destinationExecutableURL.path,
- ["--unregister-child", target.plistName, managerExecutableURL.path]
+ ["--unregister-child", target.serviceIdentifier, managerExecutableURL.path]
)
for key in ["KeepAlive.isEnabled", "AutoReset.isEnabled"] {
try runChecked(
@@ -382,17 +387,17 @@ private final class KeepAliveCleanupCommand {
}
_ = try run(
"/usr/bin/defaults",
- ["delete", target.bundleIdentifier, "KeepAlive.helperRegistrationFingerprint"],
+ ["delete", target.bundleIdentifier, "PowerHelper.registrationFingerprint"],
capturesOutput: true
)
let serviceStatus = try run(
"/bin/launchctl",
- ["print", "system/\(target.serviceLabel)"],
+ ["print", "system/\(target.serviceIdentifier)"],
capturesOutput: true
)
guard serviceStatus.status != 0 else {
- throw CleanupError.message("后台服务仍在运行, service=\(target.serviceLabel)")
+ throw CleanupError.message("后台服务仍在运行, service=\(target.serviceIdentifier)")
}
}
@@ -515,30 +520,29 @@ private final class KeepAliveCleanupCommand {
}
}
-private func runUnregisterChild(plistName: String, managerExecutable: String) -> Never {
- let label = String(plistName.dropLast(".plist".count))
- guard cancelAutoResetWakeScheduleBeforeUnregister(serviceLabel: label) else {
+private func runUnregisterChild(serviceIdentifier: String, managerExecutable: String) -> Never {
+ guard cancelAutoResetWakeScheduleBeforeUnregister(serviceIdentifier: serviceIdentifier) else {
Darwin.exit(EXIT_FAILURE)
}
do {
- let initialStatus = try runHelperManager(command: "status", executable: managerExecutable)
+ let initialStatus = try runPowerHelperManager(command: "status", executable: managerExecutable)
if initialStatus == .notRegistered || initialStatus == .notFound {
- print("后台服务未注册: service=\(plistName)")
+ print("后台服务未注册: service=\(serviceIdentifier)")
Darwin.exit(EXIT_SUCCESS)
}
- let status = try runHelperManager(command: "unregister", executable: managerExecutable)
+ let status = try runPowerHelperManager(command: "unregister", executable: managerExecutable)
guard status == .notRegistered || status == .notFound else {
- throw CleanupError.message("管理 App 未确认 Helper 已注销, status=\(status.rawValue)")
+ throw CleanupError.message("管理 App 未确认 Power Helper 已注销, status=\(status.rawValue)")
}
- print("后台服务已注销: service=\(plistName)")
+ print("后台服务已注销: service=\(serviceIdentifier)")
Darwin.exit(EXIT_SUCCESS)
} catch {
- FileHandle.standardError.write(Data("Helper 注销失败: \(error.localizedDescription)\n".utf8))
+ FileHandle.standardError.write(Data("Power Helper 注销失败: \(error.localizedDescription)\n".utf8))
Darwin.exit(EXIT_FAILURE)
}
}
-private func runHelperManager(command: String, executable: String) throws -> SMAppService.Status {
+private func runPowerHelperManager(command: String, executable: String) throws -> SMAppService.Status {
let process = Process()
let pipe = Pipe()
process.executableURL = URL(fileURLWithPath: executable)
@@ -551,9 +555,9 @@ private func runHelperManager(command: String, executable: String) throws -> SMA
throw CleanupError.message("管理 App 进程失败, command=\(command), exit=\(process.terminationStatus)")
}
- let reply: HelperManagerReply
+ let reply: PowerHelperManagerReply
do {
- reply = try JSONDecoder().decode(HelperManagerReply.self, from: data)
+ reply = try JSONDecoder().decode(PowerHelperManagerReply.self, from: data)
} catch {
throw CleanupError.message("管理 App 响应无效, command=\(command), detail=\(error.localizedDescription)")
}
@@ -576,16 +580,16 @@ private func runHelperManager(command: String, executable: String) throws -> SMA
}
}
-private func cancelAutoResetWakeScheduleBeforeUnregister(serviceLabel: String) -> Bool {
- let owner = serviceLabel + ".auto-reset"
+private func cancelAutoResetWakeScheduleBeforeUnregister(serviceIdentifier: String) -> Bool {
+ let owner = serviceIdentifier + ".auto-reset"
guard hasScheduledWakeEvent(owner: owner) else {
return true
}
let state = WakeScheduleCancellationState()
let semaphore = DispatchSemaphore(value: 0)
- let connection = NSXPCConnection(machServiceName: serviceLabel, options: .privileged)
- connection.remoteObjectInterface = NSXPCInterface(with: CleanupHelperProtocol.self)
+ let connection = NSXPCConnection(machServiceName: serviceIdentifier, options: .privileged)
+ connection.remoteObjectInterface = NSXPCInterface(with: CleanupPowerHelperProtocol.self)
let finish: @Sendable (String?) -> Void = { errorMessage in
if state.complete(errorMessage: errorMessage) {
semaphore.signal()
@@ -602,14 +606,14 @@ private func cancelAutoResetWakeScheduleBeforeUnregister(serviceLabel: String) -
let errorHandler: @Sendable (Error) -> Void = { error in
finish(error.localizedDescription)
}
- guard let helper = connection.remoteObjectProxyWithErrorHandler(errorHandler)
- as? CleanupHelperProtocol else {
+ guard let powerHelper = connection.remoteObjectProxyWithErrorHandler(errorHandler)
+ as? CleanupPowerHelperProtocol else {
connection.invalidate()
reportWakeScheduleCancellationFailure(owner: owner, detail: "服务接口无效")
return false
}
- helper.setAutoResetWakeSchedule(0) { exitCode in
+ powerHelper.setAutoResetWakeSchedule(0) { exitCode in
finish(exitCode == 0 ? nil : "code=\(exitCode)")
}
let waitResult = semaphore.wait(timeout: .now() + 10)
@@ -662,7 +666,7 @@ if arguments.first == "--unregister-child" {
)
Darwin.exit(EXIT_FAILURE)
}
- runUnregisterChild(plistName: arguments[1], managerExecutable: arguments[2])
+ runUnregisterChild(serviceIdentifier: arguments[1], managerExecutable: arguments[2])
}
do {
diff --git a/Scripts/lib/validate.sh b/Scripts/lib/validate.sh
index 8216941..11ca4be 100644
--- a/Scripts/lib/validate.sh
+++ b/Scripts/lib/validate.sh
@@ -1,6 +1,6 @@
#!/usr/bin/env bash
-validate_helper_manager_distribution() {
+validate_power_helper_manager_distribution() {
local manager_path="$1"
local architectures="$2"
local architecture=""
@@ -12,14 +12,14 @@ validate_helper_manager_distribution() {
for architecture in ${architectures}; do
if ! details="$(codesign --display --verbose=4 --arch "${architecture}" "${manager_path}" 2>&1)"; then
- validation_fail "Helper manager ${architecture} signature metadata" "codesign could not read the signature" "${details}"
+ validation_fail "Power Helper manager ${architecture} signature metadata" "codesign could not read the signature" "${details}"
return 1
fi
if ! printf '%s\n' "${details}" | grep -Eq '^CodeDirectory .*flags=.*\(runtime\)'; then
- validation_fail "Helper manager ${architecture} Hardened Runtime" "The CodeDirectory does not contain the runtime flag"
+ validation_fail "Power Helper manager ${architecture} Hardened Runtime" "The CodeDirectory does not contain the runtime flag"
return 1
fi
- validation_pass "Helper manager ${architecture} Hardened Runtime"
+ validation_pass "Power Helper manager ${architecture} Hardened Runtime"
if [[ "${CONFIGURATION}" != "Release" ]]; then
continue
@@ -28,35 +28,35 @@ validate_helper_manager_distribution() {
authority="$(printf '%s\n' "${details}" | awk '/^Authority=/ {sub(/^Authority=/, ""); print; exit}')"
timestamp="$(printf '%s\n' "${details}" | awk '/^Timestamp=/ {sub(/^Timestamp=/, ""); print; exit}')"
if [[ "${authority}" != "Developer ID Application: "* ]]; then
- validation_fail "Helper manager ${architecture} Developer ID" "Expected Developer ID Application, got ${authority:-none}"
+ validation_fail "Power Helper manager ${architecture} Developer ID" "Expected Developer ID Application, got ${authority:-none}"
return 1
fi
if [[ -z "${timestamp}" || "${timestamp}" == "none" ]]; then
- validation_fail "Helper manager ${architecture} secure timestamp" "The signature has no secure timestamp"
+ validation_fail "Power Helper manager ${architecture} secure timestamp" "The signature has no secure timestamp"
return 1
fi
- validation_field "Helper manager ${architecture} authority" "${authority}"
- validation_field "Helper manager ${architecture} timestamp" "${timestamp}"
+ validation_field "Power Helper manager ${architecture} authority" "${authority}"
+ validation_field "Power Helper manager ${architecture} timestamp" "${timestamp}"
entitlements="${TEMP_ROOT}/validation/manager-${architecture}-entitlements.plist"
: > "${entitlements}"
if ! codesign --display --arch "${architecture}" --entitlements="${entitlements}" --xml "${manager_path}" >/dev/null 2>&1; then
- validation_fail "Helper manager ${architecture} entitlements" "codesign could not read the entitlements"
+ validation_fail "Power Helper manager ${architecture} entitlements" "codesign could not read the entitlements"
return 1
fi
# 没有 entitlements 的管理 App 同样符合发布要求
if [[ -s "${entitlements}" ]]; then
if ! plutil -lint "${entitlements}" >/dev/null 2>&1; then
- validation_fail "Helper manager ${architecture} entitlements" "Invalid entitlements plist"
+ validation_fail "Power Helper manager ${architecture} entitlements" "Invalid entitlements plist"
return 1
fi
debugger_entitlement="$(read_plist_value "${entitlements}" com.apple.security.get-task-allow)"
if [[ "${debugger_entitlement}" == "true" || "${debugger_entitlement}" == "1" ]]; then
- validation_fail "Helper manager ${architecture} debugger attachment" "get-task-allow is enabled"
+ validation_fail "Power Helper manager ${architecture} debugger attachment" "get-task-allow is enabled"
return 1
fi
fi
- validation_pass "Helper manager ${architecture} distribution signature"
+ validation_pass "Power Helper manager ${architecture} distribution signature"
done
}
@@ -65,29 +65,31 @@ validate_final_app() {
local contents_path="${app_path}/Contents"
local info_plist="${contents_path}/Info.plist"
local executable_path="${contents_path}/MacOS/${PRODUCT_NAME}"
- local manager_name="CodexBar Helper"
+ local manager_name="CodexBar Power Helper"
+ local daemon_plist_name="CodexBarPowerHelper.plist"
if [[ "${CONFIGURATION}" == "Debug" ]]; then
- manager_name="CodexBar Helper Debug"
+ manager_name="CodexBar Power Helper Debug"
+ daemon_plist_name="CodexBarPowerHelper.Debug.plist"
fi
local manager_path="${contents_path}/Helpers/${manager_name}.app"
- local manager_executable="${manager_path}/Contents/MacOS/CodexBarHelperManager"
- local helper_path="${manager_path}/Contents/Resources/CodexBarHelper"
+ local manager_executable="${manager_path}/Contents/MacOS/CodexBarPowerHelperManager"
+ local power_helper_path="${manager_path}/Contents/Helpers/CodexBarPowerHelper"
local launch_daemons_path="${manager_path}/Contents/Library/LaunchDaemons"
local embedded_profile="${contents_path}/embedded.provisionprofile"
local validation_dir="${TEMP_ROOT}/validation"
local main_entitlements="${validation_dir}/main-entitlements.plist"
- local helper_entitlements="${validation_dir}/helper-entitlements.plist"
+ local power_helper_entitlements="${validation_dir}/power-helper-entitlements.plist"
local profile_plist="${validation_dir}/embedded-profile.plist"
local profile_decode_error="${validation_dir}/profile-decode-error.log"
local profile_entitlements="${validation_dir}/profile-entitlements.plist"
local signing_certificate_prefix="${validation_dir}/signing-certificate"
local signing_certificate="${signing_certificate_prefix}0"
- local helper_signing_certificate_prefix="${validation_dir}/helper-signing-certificate"
- local helper_signing_certificate="${helper_signing_certificate_prefix}0"
+ local power_helper_signing_certificate_prefix="${validation_dir}/power-helper-signing-certificate"
+ local power_helper_signing_certificate="${power_helper_signing_certificate_prefix}0"
local bundle_identifier=""
local component_identifier_prefix=""
local component_identifier_suffix=""
- local expected_helper_identifier=""
+ local expected_power_helper_identifier=""
local expected_manager_identifier=""
local display_name=""
local short_version=""
@@ -95,30 +97,30 @@ validate_final_app() {
local minimum_system_version=""
local ui_element=""
local architectures=""
- local helper_architectures=""
+ local power_helper_architectures=""
local architecture=""
local command_output=""
local signature_details=""
- local helper_signature_details=""
+ local power_helper_signature_details=""
local signature_identifier=""
- local helper_signature_identifier=""
+ local power_helper_signature_identifier=""
local signing_authority=""
local signing_timestamp=""
local signing_team=""
- local helper_signing_team=""
+ local power_helper_signing_team=""
local signing_cdhash=""
local signing_certificate_sha1=""
- local helper_signing_certificate_sha1=""
+ local power_helper_signing_certificate_sha1=""
local expected_signing_certificate=""
local normalized_expected_certificate=""
local export_certificate_selector=""
local main_application_identifier=""
- local helper_application_identifier=""
+ local power_helper_application_identifier=""
local main_team_identifier=""
local debugger_entitlement=""
- local helper_debugger_entitlement=""
+ local power_helper_debugger_entitlement=""
local app_debugger_status="disabled"
- local helper_debugger_status="disabled"
+ local power_helper_debugger_status="disabled"
local icloud_environment=""
local icloud_containers=""
local icloud_services=""
@@ -156,13 +158,13 @@ validate_final_app() {
fi
validation_pass "App bundle structure"
- if [[ ! -x "${helper_path}" ]]; then
- validation_fail "Embedded helper" "Executable helper not found at ${helper_path}"
+ if [[ ! -x "${power_helper_path}" ]]; then
+ validation_fail "Embedded Power Helper" "Executable Power Helper not found at ${power_helper_path}"
return 1
fi
- validation_pass "Embedded helper"
+ validation_pass "Embedded Power Helper"
if [[ ! -x "${manager_executable}" ]]; then
- validation_fail "Helper manager" "Executable not found at ${manager_executable}"
+ validation_fail "Power Helper manager" "Executable not found at ${manager_executable}"
return 1
fi
local manager_identifier
@@ -176,8 +178,8 @@ validate_final_app() {
component_identifier_prefix="${bundle_identifier%.debug}"
component_identifier_suffix=".debug"
fi
- expected_helper_identifier="${component_identifier_prefix}.helper${component_identifier_suffix}"
- expected_manager_identifier="${component_identifier_prefix}.helper-manager${component_identifier_suffix}"
+ expected_power_helper_identifier="${component_identifier_prefix}.helper.power${component_identifier_suffix}"
+ expected_manager_identifier="${component_identifier_prefix}.helper.power.manager${component_identifier_suffix}"
display_name="$(read_plist_value "${info_plist}" CFBundleDisplayName)"
short_version="$(read_plist_value "${info_plist}" CFBundleShortVersionString)"
build_version="$(read_plist_value "${info_plist}" CFBundleVersion)"
@@ -195,8 +197,8 @@ validate_final_app() {
return 1
fi
- if ! helper_architectures="$(lipo -archs "${helper_path}" 2>&1)"; then
- validation_fail "Helper architectures" "lipo could not inspect the helper executable" "${helper_architectures}"
+ if ! power_helper_architectures="$(lipo -archs "${power_helper_path}" 2>&1)"; then
+ validation_fail "Power Helper architectures" "lipo could not inspect the Power Helper executable" "${power_helper_architectures}"
return 1
fi
validation_pass "Architectures inspected"
@@ -208,7 +210,7 @@ validate_final_app() {
validation_field "Minimum macOS" "${minimum_system_version}"
validation_field "LSUIElement" "${ui_element}"
validation_field "App architectures" "${architectures}"
- validation_field "Helper architectures" "${helper_architectures}"
+ validation_field "Power Helper architectures" "${power_helper_architectures}"
validation_section "Code signature"
@@ -226,62 +228,62 @@ validate_final_app() {
done
validation_pass "App signature slices: ${architectures}"
- if ! command_output="$(codesign --verify --strict --verbose=4 "${helper_path}" 2>&1)"; then
- validation_fail "Helper signature" "codesign rejected the helper executable" "${command_output}"
+ if ! command_output="$(codesign --verify --strict --verbose=4 "${power_helper_path}" 2>&1)"; then
+ validation_fail "Power Helper signature" "codesign rejected the Power Helper executable" "${command_output}"
return 1
fi
- validation_pass "Helper signature"
+ validation_pass "Power Helper signature"
- for architecture in ${helper_architectures}; do
- if ! command_output="$(codesign --verify --strict --verbose=4 --arch "${architecture}" "${helper_path}" 2>&1)"; then
- validation_fail "Helper ${architecture} signature" "codesign rejected the helper ${architecture} slice" "${command_output}"
+ for architecture in ${power_helper_architectures}; do
+ if ! command_output="$(codesign --verify --strict --verbose=4 --arch "${architecture}" "${power_helper_path}" 2>&1)"; then
+ validation_fail "Power Helper ${architecture} signature" "codesign rejected the Power Helper ${architecture} slice" "${command_output}"
return 1
fi
done
- validation_pass "Helper signature slices: ${helper_architectures}"
+ validation_pass "Power Helper signature slices: ${power_helper_architectures}"
if ! signature_details="$(codesign -d --verbose=4 "${app_path}" 2>&1)"; then
validation_fail "App signature metadata" "codesign could not read the app signature" "${signature_details}"
return 1
fi
- if ! helper_signature_details="$(codesign -d --verbose=4 "${helper_path}" 2>&1)"; then
- validation_fail "Helper signature metadata" "codesign could not read the helper signature" "${helper_signature_details}"
+ if ! power_helper_signature_details="$(codesign -d --verbose=4 "${power_helper_path}" 2>&1)"; then
+ validation_fail "Power Helper signature metadata" "codesign could not read the Power Helper signature" "${power_helper_signature_details}"
return 1
fi
signature_identifier="$(printf '%s\n' "${signature_details}" | awk -F= '/^Identifier=/ {print $2; exit}')"
- helper_signature_identifier="$(printf '%s\n' "${helper_signature_details}" | awk -F= '/^Identifier=/ {print $2; exit}')"
+ power_helper_signature_identifier="$(printf '%s\n' "${power_helper_signature_details}" | awk -F= '/^Identifier=/ {print $2; exit}')"
signing_authority="$(printf '%s\n' "${signature_details}" | awk -F= '/^Authority=/ {print substr($0, index($0, "=") + 1); exit}')"
signing_timestamp="$(printf '%s\n' "${signature_details}" | awk -F= '/^Timestamp=/ {print substr($0, index($0, "=") + 1); exit}')"
signing_team="$(printf '%s\n' "${signature_details}" | awk -F= '/^TeamIdentifier=/ {print $2; exit}')"
- helper_signing_team="$(printf '%s\n' "${helper_signature_details}" | awk -F= '/^TeamIdentifier=/ {print $2; exit}')"
+ power_helper_signing_team="$(printf '%s\n' "${power_helper_signature_details}" | awk -F= '/^TeamIdentifier=/ {print $2; exit}')"
signing_cdhash="$(printf '%s\n' "${signature_details}" | awk -F= '/^CDHash=/ {print $2; exit}')"
if [[ "${signature_identifier}" != "${bundle_identifier}" ||
- "${helper_signature_identifier}" != "${expected_helper_identifier}" ||
- -z "${signing_team}" || "${helper_signing_team}" != "${signing_team}" ]]; then
+ "${power_helper_signature_identifier}" != "${expected_power_helper_identifier}" ||
+ -z "${signing_team}" || "${power_helper_signing_team}" != "${signing_team}" ]]; then
validation_fail \
"Code signature identifiers" \
- "Expected app ${bundle_identifier}, helper ${expected_helper_identifier}, and one shared team; got app ${signature_identifier}, helper ${helper_signature_identifier}, teams ${signing_team:-none}/${helper_signing_team:-none}"
+ "Expected app ${bundle_identifier}, Power Helper ${expected_power_helper_identifier}, and one shared team; got app ${signature_identifier}, Power Helper ${power_helper_signature_identifier}, teams ${signing_team:-none}/${power_helper_signing_team:-none}"
return 1
fi
validation_pass "Code signature identifiers"
if [[ "${manager_identifier}" != "${expected_manager_identifier}" ]] ||
! codesign --verify --strict --all-architectures \
- -R="anchor apple generic and certificate leaf[subject.OU] = \"${signing_team}\" and identifier \"${manager_identifier}\"" \
- "${manager_path}"; then
- validation_fail "Helper manager signature" "Unexpected identifier, team, or invalid signature"
+ -R="anchor apple generic and certificate leaf[subject.OU] = \"${signing_team}\" and identifier \"${manager_identifier}\"" \
+ "${manager_path}"; then
+ validation_fail "Power Helper manager signature" "Unexpected identifier, team, or invalid signature"
return 1
fi
local manager_architectures
manager_architectures="$(lipo -archs "${manager_executable}")"
if [[ "${manager_architectures}" != "${architectures}" ]]; then
- validation_fail "Helper manager architectures" "Expected ${architectures}, got ${manager_architectures}"
+ validation_fail "Power Helper manager architectures" "Expected ${architectures}, got ${manager_architectures}"
return 1
fi
- validation_pass "Helper manager signature and architectures"
- if ! validate_helper_manager_distribution "${manager_path}" "${manager_architectures}"; then
+ validation_pass "Power Helper manager signature and architectures"
+ if ! validate_power_helper_manager_distribution "${manager_path}" "${manager_architectures}"; then
return 1
fi
@@ -291,19 +293,19 @@ validate_final_app() {
fi
validation_pass "App Hardened Runtime"
- if ! printf '%s\n' "${helper_signature_details}" | grep -Eq '^CodeDirectory .*flags=.*\(runtime\)'; then
- validation_fail "Helper Hardened Runtime" "The helper CodeDirectory does not contain the runtime flag"
+ if ! printf '%s\n' "${power_helper_signature_details}" | grep -Eq '^CodeDirectory .*flags=.*\(runtime\)'; then
+ validation_fail "Power Helper Hardened Runtime" "The Power Helper CodeDirectory does not contain the runtime flag"
return 1
fi
- validation_pass "Helper Hardened Runtime"
+ validation_pass "Power Helper Hardened Runtime"
if ! codesign --display --extract-certificates="${signing_certificate_prefix}" "${app_path}" >/dev/null 2>&1 || [[ ! -f "${signing_certificate}" ]]; then
validation_fail "App signing certificate" "codesign could not extract the app leaf certificate"
return 1
fi
- if ! codesign --display --extract-certificates="${helper_signing_certificate_prefix}" "${helper_path}" >/dev/null 2>&1 || [[ ! -f "${helper_signing_certificate}" ]]; then
- validation_fail "Helper signing certificate" "codesign could not extract the helper leaf certificate"
+ if ! codesign --display --extract-certificates="${power_helper_signing_certificate_prefix}" "${power_helper_path}" >/dev/null 2>&1 || [[ ! -f "${power_helper_signing_certificate}" ]]; then
+ validation_fail "Power Helper signing certificate" "codesign could not extract the Power Helper leaf certificate"
return 1
fi
@@ -312,18 +314,18 @@ validate_final_app() {
return 1
fi
- if ! helper_signing_certificate_sha1="$(certificate_sha1 "${helper_signing_certificate}")"; then
- validation_fail "Helper signing certificate" "Unable to calculate the helper certificate SHA-1"
+ if ! power_helper_signing_certificate_sha1="$(certificate_sha1 "${power_helper_signing_certificate}")"; then
+ validation_fail "Power Helper signing certificate" "Unable to calculate the Power Helper certificate SHA-1"
return 1
fi
- if [[ "${helper_signing_certificate_sha1}" != "${signing_certificate_sha1}" ]]; then
+ if [[ "${power_helper_signing_certificate_sha1}" != "${signing_certificate_sha1}" ]]; then
validation_fail \
- "App and helper certificate match" \
- "App uses ${signing_certificate_sha1}, helper uses ${helper_signing_certificate_sha1}"
+ "App and Power Helper certificate match" \
+ "App uses ${signing_certificate_sha1}, Power Helper uses ${power_helper_signing_certificate_sha1}"
return 1
fi
- validation_pass "App and helper certificate match"
+ validation_pass "App and Power Helper certificate match"
expected_signing_certificate="$(read_plist_value "${EXPORT_OPTIONS_PLIST}" signingCertificate)"
normalized_expected_certificate="$(printf '%s' "${expected_signing_certificate}" | tr -d ':' | tr '[:lower:]' '[:upper:]')"
@@ -340,11 +342,11 @@ validate_final_app() {
fi
validation_field "App identifier" "${signature_identifier}"
- validation_field "Helper identifier" "${helper_signature_identifier}"
+ validation_field "Power Helper identifier" "${power_helper_signature_identifier}"
validation_field "Authority" "${signing_authority}"
validation_field "Team identifier" "${signing_team}"
validation_field "App certificate SHA-1" "${signing_certificate_sha1}"
- validation_field "Helper certificate SHA-1" "${helper_signing_certificate_sha1}"
+ validation_field "Power Helper certificate SHA-1" "${power_helper_signing_certificate_sha1}"
validation_field "Timestamp" "${signing_timestamp:-none}"
validation_field "CDHash" "${signing_cdhash}"
if [[ -n "${export_certificate_selector}" ]]; then
@@ -359,41 +361,41 @@ validate_final_app() {
fi
validation_pass "App entitlements extracted"
- if ! codesign --display --entitlements="${helper_entitlements}" --xml "${helper_path}" >/dev/null 2>&1 || [[ ! -s "${helper_entitlements}" ]]; then
- validation_fail "Helper entitlements" "codesign did not return a helper entitlements plist"
+ if ! codesign --display --entitlements="${power_helper_entitlements}" --xml "${power_helper_path}" >/dev/null 2>&1 || [[ ! -s "${power_helper_entitlements}" ]]; then
+ validation_fail "Power Helper entitlements" "codesign did not return a Power Helper entitlements plist"
return 1
fi
- validation_pass "Helper entitlements extracted"
+ validation_pass "Power Helper entitlements extracted"
main_application_identifier="$(read_plist_value "${main_entitlements}" com.apple.application-identifier)"
- helper_application_identifier="$(read_plist_value "${helper_entitlements}" com.apple.application-identifier)"
+ power_helper_application_identifier="$(read_plist_value "${power_helper_entitlements}" com.apple.application-identifier)"
main_team_identifier="$(read_plist_value "${main_entitlements}" com.apple.developer.team-identifier)"
debugger_entitlement="$(read_plist_value "${main_entitlements}" com.apple.security.get-task-allow)"
- helper_debugger_entitlement="$(read_plist_value "${helper_entitlements}" com.apple.security.get-task-allow)"
+ power_helper_debugger_entitlement="$(read_plist_value "${power_helper_entitlements}" com.apple.security.get-task-allow)"
icloud_environment="$(read_plist_compact_value "${main_entitlements}" com.apple.developer.icloud-container-environment)"
icloud_containers="$(read_plist_compact_value "${main_entitlements}" com.apple.developer.icloud-container-identifiers)"
icloud_services="$(read_plist_compact_value "${main_entitlements}" com.apple.developer.icloud-services)"
if [[ "${debugger_entitlement}" == "true" || "${debugger_entitlement}" == "1" ]]; then
app_debugger_status="allowed"
fi
- if [[ "${helper_debugger_entitlement}" == "true" || "${helper_debugger_entitlement}" == "1" ]]; then
- helper_debugger_status="allowed"
+ if [[ "${power_helper_debugger_entitlement}" == "true" || "${power_helper_debugger_entitlement}" == "1" ]]; then
+ power_helper_debugger_status="allowed"
fi
if [[ "${main_application_identifier}" != "${signing_team}.${bundle_identifier}" ||
- "${helper_application_identifier}" != "${signing_team}.${expected_helper_identifier}" ]]; then
+ "${power_helper_application_identifier}" != "${signing_team}.${expected_power_helper_identifier}" ]]; then
validation_fail \
"Entitlement application identifiers" \
- "Expected ${signing_team}.${bundle_identifier} and ${signing_team}.${expected_helper_identifier}; got ${main_application_identifier:-none} and ${helper_application_identifier:-none}"
+ "Expected ${signing_team}.${bundle_identifier} and ${signing_team}.${expected_power_helper_identifier}; got ${main_application_identifier:-none} and ${power_helper_application_identifier:-none}"
return 1
fi
validation_pass "Entitlement application identifiers"
if [[ "${CONFIGURATION}" == "Release" &&
- ("${app_debugger_status}" == "allowed" || "${helper_debugger_status}" == "allowed") ]]; then
+ ("${app_debugger_status}" == "allowed" || "${power_helper_debugger_status}" == "allowed") ]]; then
validation_fail \
"Release debugger attachment" \
- "get-task-allow is enabled for app=${debugger_entitlement:-false}, helper=${helper_debugger_entitlement:-false}"
+ "get-task-allow is enabled for app=${debugger_entitlement:-false}, Power Helper=${power_helper_debugger_entitlement:-false}"
return 1
fi
@@ -402,20 +404,20 @@ validate_final_app() {
return 1
fi
- if ! command_output="$(plutil -p "${helper_entitlements}" 2>&1)"; then
- validation_fail "Helper entitlements" "Unable to read helper entitlements" "${command_output}"
+ if ! command_output="$(plutil -p "${power_helper_entitlements}" 2>&1)"; then
+ validation_fail "Power Helper entitlements" "Unable to read Power Helper entitlements" "${command_output}"
return 1
fi
validation_pass "Debugger attachment policy"
validation_field "App identifier" "${main_application_identifier}"
- validation_field "Helper identifier" "${helper_application_identifier}"
+ validation_field "Power Helper identifier" "${power_helper_application_identifier}"
validation_field "Team identifier" "${main_team_identifier}"
validation_field "iCloud environment" "${icloud_environment}"
validation_field "iCloud containers" "${icloud_containers}"
validation_field "iCloud services" "${icloud_services}"
validation_field "App debugger attachment" "${app_debugger_status}"
- validation_field "Helper debugger attachment" "${helper_debugger_status}"
+ validation_field "Power Helper debugger attachment" "${power_helper_debugger_status}"
validation_section "LaunchDaemon"
@@ -434,16 +436,20 @@ validate_final_app() {
validation_fail "LaunchDaemon plist count" "Expected exactly 1 plist, found ${launch_daemon_count}"
return 1
fi
+ if [[ "${launch_daemon_plist}" != "${launch_daemons_path}/${daemon_plist_name}" ]]; then
+ validation_fail "LaunchDaemon plist name" "Expected ${daemon_plist_name}, got $(basename "${launch_daemon_plist}")"
+ return 1
+ fi
launch_daemon_label="$(read_plist_value "${launch_daemon_plist}" Label)"
launch_daemon_bundle_identifier="$(read_plist_value "${launch_daemon_plist}" AssociatedBundleIdentifiers:0)"
launch_daemon_program="$(read_plist_value "${launch_daemon_plist}" BundleProgram)"
- if [[ "${launch_daemon_label}" != "${expected_helper_identifier}" ||
+ if [[ "${launch_daemon_label}" != "${expected_power_helper_identifier}" ||
"${launch_daemon_bundle_identifier}" != "${manager_identifier}" ||
- "${launch_daemon_program}" != "Contents/Resources/CodexBarHelper" ]]; then
+ "${launch_daemon_program}" != "Contents/Helpers/CodexBarPowerHelper" ]]; then
validation_fail \
"LaunchDaemon configuration" \
- "Expected label ${expected_helper_identifier}, bundle ${manager_identifier}, and program Contents/Resources/CodexBarHelper; got ${launch_daemon_label:-none}, ${launch_daemon_bundle_identifier:-none}, ${launch_daemon_program:-none}"
+ "Expected label ${expected_power_helper_identifier}, bundle ${manager_identifier}, and program Contents/Helpers/CodexBarPowerHelper; got ${launch_daemon_label:-none}, ${launch_daemon_bundle_identifier:-none}, ${launch_daemon_program:-none}"
return 1
fi
validation_pass "LaunchDaemon configuration"
diff --git a/Shared/BoundedProcess.swift b/Shared/BoundedProcess.swift
index dba28cb..b799eb2 100644
--- a/Shared/BoundedProcess.swift
+++ b/Shared/BoundedProcess.swift
@@ -54,7 +54,7 @@ nonisolated enum BoundedProcess {
if case let .launchFailed(message) = completion {
return message
}
- // helper 和后台服务保留替换无效 UTF-8 字节的展示行为
+ // Power Helper 和后台服务保留替换无效 UTF-8 字节的展示行为
// swiftlint:disable:next optional_data_string_conversion
return String(decoding: standardOutput.data, as: UTF8.self)
}
diff --git a/CodexBarTests/Activity/ActivityArchitectureTests.swift b/Tests/App/Activity/ActivityArchitectureTests.swift
similarity index 100%
rename from CodexBarTests/Activity/ActivityArchitectureTests.swift
rename to Tests/App/Activity/ActivityArchitectureTests.swift
diff --git a/CodexBarTests/Activity/ActivityBackfillTests.swift b/Tests/App/Activity/ActivityBackfillTests.swift
similarity index 100%
rename from CodexBarTests/Activity/ActivityBackfillTests.swift
rename to Tests/App/Activity/ActivityBackfillTests.swift
diff --git a/CodexBarTests/Activity/ActivityIsolationTests.swift b/Tests/App/Activity/ActivityIsolationTests.swift
similarity index 100%
rename from CodexBarTests/Activity/ActivityIsolationTests.swift
rename to Tests/App/Activity/ActivityIsolationTests.swift
diff --git a/CodexBarTests/Activity/ActivityLivePresentationTests.swift b/Tests/App/Activity/ActivityLivePresentationTests.swift
similarity index 100%
rename from CodexBarTests/Activity/ActivityLivePresentationTests.swift
rename to Tests/App/Activity/ActivityLivePresentationTests.swift
diff --git a/CodexBarTests/Activity/ActivityReaderBoundsTests.swift b/Tests/App/Activity/ActivityReaderBoundsTests.swift
similarity index 100%
rename from CodexBarTests/Activity/ActivityReaderBoundsTests.swift
rename to Tests/App/Activity/ActivityReaderBoundsTests.swift
diff --git a/CodexBarTests/Activity/ActivityRecoveryTests.swift b/Tests/App/Activity/ActivityRecoveryTests.swift
similarity index 100%
rename from CodexBarTests/Activity/ActivityRecoveryTests.swift
rename to Tests/App/Activity/ActivityRecoveryTests.swift
diff --git a/CodexBarTests/Activity/ActivitySchedulingTests.swift b/Tests/App/Activity/ActivitySchedulingTests.swift
similarity index 100%
rename from CodexBarTests/Activity/ActivitySchedulingTests.swift
rename to Tests/App/Activity/ActivitySchedulingTests.swift
diff --git a/CodexBarTests/Activity/ActivityTaskTests.swift b/Tests/App/Activity/ActivityTaskTests.swift
similarity index 100%
rename from CodexBarTests/Activity/ActivityTaskTests.swift
rename to Tests/App/Activity/ActivityTaskTests.swift
diff --git a/CodexBarTests/Activity/ActivityTokenUsageTests.swift b/Tests/App/Activity/ActivityTokenUsageTests.swift
similarity index 100%
rename from CodexBarTests/Activity/ActivityTokenUsageTests.swift
rename to Tests/App/Activity/ActivityTokenUsageTests.swift
diff --git a/CodexBarTests/Activity/ActivityUpdateTests.swift b/Tests/App/Activity/ActivityUpdateTests.swift
similarity index 100%
rename from CodexBarTests/Activity/ActivityUpdateTests.swift
rename to Tests/App/Activity/ActivityUpdateTests.swift
diff --git a/CodexBarTests/Activity/AppServerActivityTests.swift b/Tests/App/Activity/AppServerActivityTests.swift
similarity index 100%
rename from CodexBarTests/Activity/AppServerActivityTests.swift
rename to Tests/App/Activity/AppServerActivityTests.swift
diff --git a/CodexBarTests/Activity/ProtectionRecoveryTests.swift b/Tests/App/Activity/ProtectionRecoveryTests.swift
similarity index 100%
rename from CodexBarTests/Activity/ProtectionRecoveryTests.swift
rename to Tests/App/Activity/ProtectionRecoveryTests.swift
diff --git a/CodexBarTests/Activity/ProtectionStoreTests.swift b/Tests/App/Activity/ProtectionStoreTests.swift
similarity index 100%
rename from CodexBarTests/Activity/ProtectionStoreTests.swift
rename to Tests/App/Activity/ProtectionStoreTests.swift
diff --git a/CodexBarTests/Activity/TurnLifecycleSnapshotTests.swift b/Tests/App/Activity/TurnLifecycleSnapshotTests.swift
similarity index 100%
rename from CodexBarTests/Activity/TurnLifecycleSnapshotTests.swift
rename to Tests/App/Activity/TurnLifecycleSnapshotTests.swift
diff --git a/CodexBarTests/Activity/TurnTokenCumulativeTests.swift b/Tests/App/Activity/TurnTokenCumulativeTests.swift
similarity index 100%
rename from CodexBarTests/Activity/TurnTokenCumulativeTests.swift
rename to Tests/App/Activity/TurnTokenCumulativeTests.swift
diff --git a/CodexBarTests/AppServer/AppServerLogTests.swift b/Tests/App/AppServer/AppServerLogTests.swift
similarity index 100%
rename from CodexBarTests/AppServer/AppServerLogTests.swift
rename to Tests/App/AppServer/AppServerLogTests.swift
diff --git a/CodexBarTests/AppServer/AppServerRPCTests.swift b/Tests/App/AppServer/AppServerRPCTests.swift
similarity index 100%
rename from CodexBarTests/AppServer/AppServerRPCTests.swift
rename to Tests/App/AppServer/AppServerRPCTests.swift
diff --git a/CodexBarTests/AppServer/AppServerRequestBudgetTests.swift b/Tests/App/AppServer/AppServerRequestBudgetTests.swift
similarity index 100%
rename from CodexBarTests/AppServer/AppServerRequestBudgetTests.swift
rename to Tests/App/AppServer/AppServerRequestBudgetTests.swift
diff --git a/CodexBarTests/AppServer/AppServerSessionTests.swift b/Tests/App/AppServer/AppServerSessionTests.swift
similarity index 100%
rename from CodexBarTests/AppServer/AppServerSessionTests.swift
rename to Tests/App/AppServer/AppServerSessionTests.swift
diff --git a/CodexBarTests/AppServer/AppServerStartupTests.swift b/Tests/App/AppServer/AppServerStartupTests.swift
similarity index 100%
rename from CodexBarTests/AppServer/AppServerStartupTests.swift
rename to Tests/App/AppServer/AppServerStartupTests.swift
diff --git a/CodexBarTests/Codex/CodexVersionProcessTests.swift b/Tests/App/Codex/CodexVersionProcessTests.swift
similarity index 100%
rename from CodexBarTests/Codex/CodexVersionProcessTests.swift
rename to Tests/App/Codex/CodexVersionProcessTests.swift
diff --git a/CodexBarTests/Codex/CodexVersionTests.swift b/Tests/App/Codex/CodexVersionTests.swift
similarity index 100%
rename from CodexBarTests/Codex/CodexVersionTests.swift
rename to Tests/App/Codex/CodexVersionTests.swift
diff --git a/CodexBarTests/CodexStatus/AccountNotificationTests.swift b/Tests/App/CodexStatus/AccountNotificationTests.swift
similarity index 100%
rename from CodexBarTests/CodexStatus/AccountNotificationTests.swift
rename to Tests/App/CodexStatus/AccountNotificationTests.swift
diff --git a/CodexBarTests/CodexStatus/AutoResetControllerTests.swift b/Tests/App/CodexStatus/AutoResetControllerTests.swift
similarity index 100%
rename from CodexBarTests/CodexStatus/AutoResetControllerTests.swift
rename to Tests/App/CodexStatus/AutoResetControllerTests.swift
diff --git a/CodexBarTests/CodexStatus/AutoResetScheduleTests.swift b/Tests/App/CodexStatus/AutoResetScheduleTests.swift
similarity index 100%
rename from CodexBarTests/CodexStatus/AutoResetScheduleTests.swift
rename to Tests/App/CodexStatus/AutoResetScheduleTests.swift
diff --git a/CodexBarTests/CodexStatus/CodexQuotaAndIdentityTests.swift b/Tests/App/CodexStatus/CodexQuotaAndIdentityTests.swift
similarity index 100%
rename from CodexBarTests/CodexStatus/CodexQuotaAndIdentityTests.swift
rename to Tests/App/CodexStatus/CodexQuotaAndIdentityTests.swift
diff --git a/CodexBarTests/CodexStatus/CodexServiceStatusTests.swift b/Tests/App/CodexStatus/CodexServiceStatusTests.swift
similarity index 100%
rename from CodexBarTests/CodexStatus/CodexServiceStatusTests.swift
rename to Tests/App/CodexStatus/CodexServiceStatusTests.swift
diff --git a/CodexBarTests/CodexStatus/LowQuotaObservationTests.swift b/Tests/App/CodexStatus/LowQuotaObservationTests.swift
similarity index 100%
rename from CodexBarTests/CodexStatus/LowQuotaObservationTests.swift
rename to Tests/App/CodexStatus/LowQuotaObservationTests.swift
diff --git a/CodexBarTests/History/AggregationPolicyTests.swift b/Tests/App/History/AggregationPolicyTests.swift
similarity index 100%
rename from CodexBarTests/History/AggregationPolicyTests.swift
rename to Tests/App/History/AggregationPolicyTests.swift
diff --git a/CodexBarTests/History/AppServerEventStorageTests.swift b/Tests/App/History/AppServerEventStorageTests.swift
similarity index 100%
rename from CodexBarTests/History/AppServerEventStorageTests.swift
rename to Tests/App/History/AppServerEventStorageTests.swift
diff --git a/CodexBarTests/History/HistoryAggregationTests.swift b/Tests/App/History/HistoryAggregationTests.swift
similarity index 100%
rename from CodexBarTests/History/HistoryAggregationTests.swift
rename to Tests/App/History/HistoryAggregationTests.swift
diff --git a/CodexBarTests/History/HistoryDatabaseStoreTests.swift b/Tests/App/History/HistoryDatabaseStoreTests.swift
similarity index 100%
rename from CodexBarTests/History/HistoryDatabaseStoreTests.swift
rename to Tests/App/History/HistoryDatabaseStoreTests.swift
diff --git a/CodexBarTests/History/HistoryDatabaseTests.swift b/Tests/App/History/HistoryDatabaseTests.swift
similarity index 100%
rename from CodexBarTests/History/HistoryDatabaseTests.swift
rename to Tests/App/History/HistoryDatabaseTests.swift
diff --git a/CodexBarTests/History/JSONLinesAndActivityDataTests.swift b/Tests/App/History/JSONLinesAndActivityDataTests.swift
similarity index 100%
rename from CodexBarTests/History/JSONLinesAndActivityDataTests.swift
rename to Tests/App/History/JSONLinesAndActivityDataTests.swift
diff --git a/CodexBarTests/History/StorageEvolutionTests.swift b/Tests/App/History/StorageEvolutionTests.swift
similarity index 100%
rename from CodexBarTests/History/StorageEvolutionTests.swift
rename to Tests/App/History/StorageEvolutionTests.swift
diff --git a/CodexBarTests/History/StorageRetentionTests.swift b/Tests/App/History/StorageRetentionTests.swift
similarity index 100%
rename from CodexBarTests/History/StorageRetentionTests.swift
rename to Tests/App/History/StorageRetentionTests.swift
diff --git a/CodexBarTests/History/TokenUsageHistoryTests.swift b/Tests/App/History/TokenUsageHistoryTests.swift
similarity index 100%
rename from CodexBarTests/History/TokenUsageHistoryTests.swift
rename to Tests/App/History/TokenUsageHistoryTests.swift
diff --git a/CodexBarTests/KeepAlive/HelperManagerClientTests.swift b/Tests/App/KeepAlive/PowerHelperManagerClientTests.swift
similarity index 59%
rename from CodexBarTests/KeepAlive/HelperManagerClientTests.swift
rename to Tests/App/KeepAlive/PowerHelperManagerClientTests.swift
index c3bae8b..82067e9 100644
--- a/CodexBarTests/KeepAlive/HelperManagerClientTests.swift
+++ b/Tests/App/KeepAlive/PowerHelperManagerClientTests.swift
@@ -3,26 +3,26 @@ import ServiceManagement
import Testing
@Suite(.timeLimit(.minutes(1)))
-struct HelperManagerClientTests {
+struct PowerHelperManagerClientTests {
@Test func transientStatusFailureRecoversWithinSameRequest() async throws {
- let execution = HelperManagerExecutionStub(failures: 1, status: .enabled)
- let client = HelperManagerClient(retryDelay: .zero, executeCommand: { try await execution.execute($0) })
+ let execution = PowerHelperManagerExecutionStub(failures: 1, status: .enabled)
+ let client = PowerHelperManagerClient(retryDelay: .zero, executeCommand: { try await execution.execute($0) })
#expect(try await client.perform(.status) == .enabled)
#expect(await execution.commands == [.status, .status])
}
@Test(arguments: [SMAppService.Status.notRegistered, .enabled, .requiresApproval, .notFound])
func validStatusIsNeverRetried(_ status: SMAppService.Status) async throws {
- let execution = HelperManagerExecutionStub(failures: 0, status: status)
- let client = HelperManagerClient(retryDelay: .zero, executeCommand: { try await execution.execute($0) })
+ let execution = PowerHelperManagerExecutionStub(failures: 0, status: status)
+ let client = PowerHelperManagerClient(retryDelay: .zero, executeCommand: { try await execution.execute($0) })
#expect(try await client.perform(.status) == status)
#expect(await execution.commands == [.status])
}
@Test func persistentFailureStopsAfterThreeAttemptsAndAllowsLaterRefresh() async throws {
- let execution = HelperManagerExecutionStub(failures: 3, status: .enabled)
- let client = HelperManagerClient(retryDelay: .zero, executeCommand: { try await execution.execute($0) })
- await #expect(throws: HelperManagerClient.ClientError.self) {
+ let execution = PowerHelperManagerExecutionStub(failures: 3, status: .enabled)
+ let client = PowerHelperManagerClient(retryDelay: .zero, executeCommand: { try await execution.execute($0) })
+ await #expect(throws: PowerHelperManagerClient.ClientError.self) {
try await client.perform(.status)
}
#expect(await execution.commands.count == 3)
@@ -30,19 +30,19 @@ struct HelperManagerClientTests {
#expect(await execution.commands.count == 4)
}
- @Test(arguments: [HelperManagement.Command.register, .unregister])
- func mutationsAreNeverRetried(_ command: HelperManagement.Command) async {
- let execution = HelperManagerExecutionStub(failures: 3, status: .enabled)
- let client = HelperManagerClient(retryDelay: .zero, executeCommand: { try await execution.execute($0) })
- await #expect(throws: HelperManagerClient.ClientError.self) {
+ @Test(arguments: [PowerHelperManagement.Command.register, .unregister])
+ func mutationsAreNeverRetried(_ command: PowerHelperManagement.Command) async {
+ let execution = PowerHelperManagerExecutionStub(failures: 3, status: .enabled)
+ let client = PowerHelperManagerClient(retryDelay: .zero, executeCommand: { try await execution.execute($0) })
+ await #expect(throws: PowerHelperManagerClient.ClientError.self) {
try await client.perform(command)
}
#expect(await execution.commands == [command])
}
@Test func cancellationStopsRetryAndAllowsNextRequest() async throws {
- let execution = HelperManagerExecutionStub(failures: 1, status: .enabled)
- let client = HelperManagerClient(retryDelay: .seconds(30), executeCommand: { try await execution.execute($0) })
+ let execution = PowerHelperManagerExecutionStub(failures: 1, status: .enabled)
+ let client = PowerHelperManagerClient(retryDelay: .seconds(30), executeCommand: { try await execution.execute($0) })
let request = Task { try await client.perform(.status) }
await execution.waitForFirstAttempt()
request.cancel()
@@ -57,47 +57,47 @@ struct HelperManagerClientTests {
@Test(arguments: [SMAppService.Status.notRegistered, .enabled, .requiresApproval, .notFound])
func statusKeepsSystemMeaning(_ status: SMAppService.Status) throws {
let data = try reply(status)
- #expect(try HelperManagerClient.status(from: data, command: .status) == status)
+ #expect(try PowerHelperManagerClient.status(from: data, command: .status) == status)
}
@Test func pendingApprovalIsRegisteredButNotEnabled() throws {
let data = try reply(.requiresApproval, errorDomain: SMAppServiceErrorDomain, errorCode: 1)
- let status = try HelperManagerClient.status(from: data, command: .register)
+ let status = try PowerHelperManagerClient.status(from: data, command: .register)
#expect(status == .requiresApproval)
- #expect(KeepAliveController.HelperStatus(status).isRegisteredOrAwaitingApproval)
+ #expect(KeepAliveController.PowerHelperStatus(status).isRegisteredOrAwaitingApproval)
}
@Test func registrationFailureCannotBeMistakenForApproval() throws {
let data = try reply(.notRegistered, errorDomain: SMAppServiceErrorDomain, errorCode: 1)
#expect(throws: NSError.self) {
- try HelperManagerClient.status(from: data, command: .register)
+ try PowerHelperManagerClient.status(from: data, command: .register)
}
}
@Test func unregistrationFailureIsNotHiddenByEnabledStatus() throws {
let data = try reply(.enabled, errorDomain: SMAppServiceErrorDomain, errorCode: 1)
#expect(throws: NSError.self) {
- try HelperManagerClient.status(from: data, command: .unregister)
+ try PowerHelperManagerClient.status(from: data, command: .unregister)
}
}
@Test func malformedReplyDoesNotBecomeNotRegistered() {
for data in [Data(), Data("{}".utf8), Data("{\"status\":999}".utf8)] {
#expect(throws: (any Error).self) {
- try HelperManagerClient.status(from: data, command: .status)
+ try PowerHelperManagerClient.status(from: data, command: .status)
}
}
}
private func reply(_ status: SMAppService.Status, errorDomain: String? = nil, errorCode: Int? = nil) throws -> Data {
- try JSONEncoder().encode(HelperManagement.Reply(status: status.rawValue, errorDomain: errorDomain, errorCode: errorCode))
+ try JSONEncoder().encode(PowerHelperManagement.Reply(status: status.rawValue, errorDomain: errorDomain, errorCode: errorCode))
}
}
-private actor HelperManagerExecutionStub {
+private actor PowerHelperManagerExecutionStub {
private var failures: Int
private let status: SMAppService.Status
- private(set) var commands: [HelperManagement.Command] = []
+ private(set) var commands: [PowerHelperManagement.Command] = []
private var firstAttempt: CheckedContinuation<Void, Never>?
init(failures: Int, status: SMAppService.Status) {
@@ -105,13 +105,13 @@ private actor HelperManagerExecutionStub {
self.status = status
}
- func execute(_ command: HelperManagement.Command) throws -> SMAppService.Status {
+ func execute(_ command: PowerHelperManagement.Command) throws -> SMAppService.Status {
commands.append(command)
firstAttempt?.resume()
firstAttempt = nil
if failures > 0 {
failures -= 1
- throw HelperManagerClient.ClientError.executionFailed
+ throw PowerHelperManagerClient.ClientError.executionFailed
}
return status
}
diff --git a/CodexBarTests/KeepAlive/HelperPackageValidationTests.swift b/Tests/App/KeepAlive/PowerHelperPackageValidationTests.swift
similarity index 63%
rename from CodexBarTests/KeepAlive/HelperPackageValidationTests.swift
rename to Tests/App/KeepAlive/PowerHelperPackageValidationTests.swift
index b794519..fc7350f 100644
--- a/CodexBarTests/KeepAlive/HelperPackageValidationTests.swift
+++ b/Tests/App/KeepAlive/PowerHelperPackageValidationTests.swift
@@ -1,10 +1,10 @@
import Foundation
import Testing
-struct HelperPackageValidationTests {
+struct PowerHelperPackageValidationTests {
@Test func concurrentRefreshesShareOneInspection() async throws {
let probe = PackageInspectionProbe()
- let validation = HelperPackageValidation { await probe.inspect() }
+ let validation = PowerHelperPackageValidation { await probe.inspect() }
defer { validation.cancel() }
var completions = 0
validation.onValidated = { completions += 1 }
@@ -23,7 +23,7 @@ struct HelperPackageValidationTests {
@Test func cancelledInspectionCannotOverwriteReplacement() async throws {
let probe = PackageInspectionProbe()
- let validation = HelperPackageValidation { await probe.inspect() }
+ let validation = PowerHelperPackageValidation { await probe.inspect() }
defer { validation.cancel() }
var completions = 0
validation.onValidated = { completions += 1 }
@@ -44,7 +44,7 @@ struct HelperPackageValidationTests {
@Test func failedInspectionClearsPreviousFingerprint() async throws {
let probe = PackageInspectionProbe()
- let validation = HelperPackageValidation { await probe.inspect() }
+ let validation = PowerHelperPackageValidation { await probe.inspect() }
defer { validation.cancel() }
validation.refresh()
try await probe.waitForRequests(1)
@@ -68,31 +68,31 @@ struct HelperPackageValidationTests {
let preferences = try TestPreferences()
defer { preferences.remove() }
let defaults = preferences.defaults
- _ = HelperConfiguration.beginUpdate(defaults: defaults, requiresSleepReset: true, fingerprint: "first")
- HelperConfiguration.recordRegistration(defaults: defaults, status: .enabled, fingerprint: "first")
- #expect(!HelperConfiguration.registrationNeedsRefresh(defaults: defaults, fingerprint: "first"))
- #expect(HelperConfiguration.registrationNeedsRefresh(defaults: defaults, fingerprint: "second"))
- _ = HelperConfiguration.beginUpdate(defaults: defaults, requiresSleepReset: false, fingerprint: "second")
- HelperConfiguration.recordRegistration(defaults: defaults, status: .requiresApproval, fingerprint: "second")
- HelperConfiguration.completeUpdate("first", defaults: defaults)
- #expect(HelperConfiguration.pendingUpdateIdentifier(defaults: defaults, fingerprint: "second") == "second")
- HelperConfiguration.completeUpdate("second", defaults: defaults)
- #expect(HelperConfiguration.pendingUpdateIdentifier(defaults: defaults, fingerprint: "second") == nil)
+ _ = PowerHelperConfiguration.beginUpdate(defaults: defaults, requiresSleepReset: true, fingerprint: "first")
+ PowerHelperConfiguration.recordRegistration(defaults: defaults, status: .enabled, fingerprint: "first")
+ #expect(!PowerHelperConfiguration.registrationNeedsRefresh(defaults: defaults, fingerprint: "first"))
+ #expect(PowerHelperConfiguration.registrationNeedsRefresh(defaults: defaults, fingerprint: "second"))
+ _ = PowerHelperConfiguration.beginUpdate(defaults: defaults, requiresSleepReset: false, fingerprint: "second")
+ PowerHelperConfiguration.recordRegistration(defaults: defaults, status: .requiresApproval, fingerprint: "second")
+ PowerHelperConfiguration.completeUpdate("first", defaults: defaults)
+ #expect(PowerHelperConfiguration.pendingUpdateIdentifier(defaults: defaults, fingerprint: "second") == "second")
+ PowerHelperConfiguration.completeUpdate("second", defaults: defaults)
+ #expect(PowerHelperConfiguration.pendingUpdateIdentifier(defaults: defaults, fingerprint: "second") == nil)
}
}
private actor PackageInspectionProbe {
- private var replies: [CheckedContinuation<HelperPackageSnapshot, Never>?] = []
+ private var replies: [CheckedContinuation<PowerHelperPackageSnapshot, Never>?] = []
var count: Int {
replies.count
}
- func inspect() async -> HelperPackageSnapshot {
+ func inspect() async -> PowerHelperPackageSnapshot {
await withCheckedContinuation { replies.append($0) }
}
- func finish(_ index: Int, fingerprint: String, issue: HelperPackageIssue? = nil) {
- replies[index]?.resume(returning: HelperPackageSnapshot(issue: issue, fingerprint: fingerprint))
+ func finish(_ index: Int, fingerprint: String, issue: PowerHelperPackageIssue? = nil) {
+ replies[index]?.resume(returning: PowerHelperPackageSnapshot(issue: issue, fingerprint: fingerprint))
replies[index] = nil
}
diff --git a/CodexBarTests/KeepAlive/HelperStatusMonitorTests.swift b/Tests/App/KeepAlive/PowerHelperStatusMonitorTests.swift
similarity index 83%
rename from CodexBarTests/KeepAlive/HelperStatusMonitorTests.swift
rename to Tests/App/KeepAlive/PowerHelperStatusMonitorTests.swift
index f61f8ab..10b9a25 100644
--- a/CodexBarTests/KeepAlive/HelperStatusMonitorTests.swift
+++ b/Tests/App/KeepAlive/PowerHelperStatusMonitorTests.swift
@@ -2,9 +2,9 @@ import Foundation
import Testing
@Suite(.timeLimit(.minutes(1)))
-struct HelperStatusMonitorTests {
+struct PowerHelperStatusMonitorTests {
@Test func observationCanRestartAfterCancellationBeforeFirstTick() async {
- let monitor = HelperStatusMonitor()
+ let monitor = PowerHelperStatusMonitor()
defer { monitor.cancelObservation() }
let finished = MonitorCheckpoint()
monitor.startObservation(interval: .seconds(60)) {
@@ -19,7 +19,7 @@ struct HelperStatusMonitorTests {
}
@Test func cancelledObservationCannotClearReplacementWhileItsActionFinishes() async {
- let monitor = HelperStatusMonitor()
+ let monitor = PowerHelperStatusMonitor()
defer { monitor.cancelObservation() }
let oldEntered = MonitorCheckpoint()
let oldRelease = MonitorCheckpoint()
@@ -52,9 +52,9 @@ struct HelperStatusMonitorTests {
}
@Test func cancelledStatusReplyCannotFinishNewWakeRequest() async {
- let monitor = HelperStatusMonitor()
- let helper = MonitorHelper()
- let connection = MonitorConnection(helper: helper)
+ let monitor = PowerHelperStatusMonitor()
+ let powerHelper = MonitorPowerHelper()
+ let connection = MonitorConnection(powerHelper: powerHelper)
defer { monitor.cancelRequest() }
let statusTask = Task {
await monitor.fetch(
@@ -64,7 +64,7 @@ struct HelperStatusMonitorTests {
onTimeout: { Issue.record("Unexpected timeout") }
)
}
- await helper.statusRequested.wait()
+ await powerHelper.statusRequested.wait()
#expect(monitor.isRequestInFlight)
monitor.cancelRequest()
#expect(!monitor.isRequestInFlight)
@@ -73,10 +73,10 @@ struct HelperStatusMonitorTests {
let wakeTask = Task {
await monitor.setAutoResetWakeSchedule(connection: connection, unixTimestamp: 0, timeout: .seconds(60))
}
- await helper.wakeRequested.wait()
- helper.statusReply?(0, CodexBarSleepOwnershipState.idle.rawValue, 0, false)
+ await powerHelper.wakeRequested.wait()
+ powerHelper.statusReply?(0, CodexBarSleepOwnershipState.idle.rawValue, 0, false)
#expect(monitor.isRequestInFlight)
- helper.wakeReply?(0)
+ powerHelper.wakeReply?(0)
guard case .success = await wakeTask.value else {
Issue.record("New wake request did not succeed")
return
@@ -85,9 +85,9 @@ struct HelperStatusMonitorTests {
}
@Test func timeoutClearsRequestAndLateReplyDoesNotPreventReuse() async {
- let monitor = HelperStatusMonitor()
- let helper = MonitorHelper()
- let connection = MonitorConnection(helper: helper)
+ let monitor = PowerHelperStatusMonitor()
+ let powerHelper = MonitorPowerHelper()
+ let connection = MonitorConnection(powerHelper: powerHelper)
defer { monitor.cancelRequest() }
let result = await monitor.setAutoResetWakeSchedule(connection: connection, unixTimestamp: 0, timeout: .zero)
guard case .timedOut = result else {
@@ -95,7 +95,7 @@ struct HelperStatusMonitorTests {
return
}
#expect(!monitor.isRequestInFlight)
- helper.wakeReply?(0)
+ powerHelper.wakeReply?(0)
let statusTask = Task {
await monitor.fetch(
@@ -105,8 +105,8 @@ struct HelperStatusMonitorTests {
onTimeout: { Issue.record("Unexpected timeout") }
)
}
- await helper.statusRequested.wait()
- helper.statusReply?(0, CodexBarSleepOwnershipState.owned.rawValue, 1, true)
+ await powerHelper.statusRequested.wait()
+ powerHelper.statusReply?(0, CodexBarSleepOwnershipState.owned.rawValue, 1, true)
let status = await statusTask.value
#expect(status?.ownership == .owned)
#expect(status?.activeClientCount == 1)
@@ -116,20 +116,20 @@ struct HelperStatusMonitorTests {
}
private final nonisolated class MonitorConnection: NSXPCConnection {
- let helper: MonitorHelper
+ let powerHelper: MonitorPowerHelper
- init(helper: MonitorHelper) {
- self.helper = helper
+ init(powerHelper: MonitorPowerHelper) {
+ self.powerHelper = powerHelper
super.init()
}
override func remoteObjectProxyWithErrorHandler(_: @escaping (any Error) -> Void) -> Any {
- helper
+ powerHelper
}
}
@MainActor
-private final class MonitorHelper: NSObject, CodexBarHelperProtocol {
+private final class MonitorPowerHelper: NSObject, CodexBarPowerHelperProtocol {
let statusRequested = MonitorCheckpoint()
let wakeRequested = MonitorCheckpoint()
var statusReply: (@Sendable (Int32, Int, Int, Bool) -> Void)?
diff --git a/CodexBarTests/KeepAlive/SystemSleepServiceTests.swift b/Tests/App/KeepAlive/SystemSleepServiceTests.swift
similarity index 100%
rename from CodexBarTests/KeepAlive/SystemSleepServiceTests.swift
rename to Tests/App/KeepAlive/SystemSleepServiceTests.swift
diff --git a/CodexBarTests/Presentation/ActivityCardLayoutTests.swift b/Tests/App/Presentation/ActivityCardLayoutTests.swift
similarity index 100%
rename from CodexBarTests/Presentation/ActivityCardLayoutTests.swift
rename to Tests/App/Presentation/ActivityCardLayoutTests.swift
diff --git a/CodexBarTests/Presentation/ActivityPresentationTests.swift b/Tests/App/Presentation/ActivityPresentationTests.swift
similarity index 100%
rename from CodexBarTests/Presentation/ActivityPresentationTests.swift
rename to Tests/App/Presentation/ActivityPresentationTests.swift
diff --git a/CodexBarTests/Presentation/DateAndPresentationTests.swift b/Tests/App/Presentation/DateAndPresentationTests.swift
similarity index 100%
rename from CodexBarTests/Presentation/DateAndPresentationTests.swift
rename to Tests/App/Presentation/DateAndPresentationTests.swift
diff --git a/CodexBarTests/Presentation/LogPreviewTests.swift b/Tests/App/Presentation/LogPreviewTests.swift
similarity index 100%
rename from CodexBarTests/Presentation/LogPreviewTests.swift
rename to Tests/App/Presentation/LogPreviewTests.swift
diff --git a/CodexBarTests/Presentation/SettingsTests.swift b/Tests/App/Presentation/SettingsTests.swift
similarity index 100%
rename from CodexBarTests/Presentation/SettingsTests.swift
rename to Tests/App/Presentation/SettingsTests.swift
diff --git a/CodexBarTests/Presentation/TaskGlowPreviewTests.swift b/Tests/App/Presentation/TaskGlowPreviewTests.swift
similarity index 100%
rename from CodexBarTests/Presentation/TaskGlowPreviewTests.swift
rename to Tests/App/Presentation/TaskGlowPreviewTests.swift
diff --git a/CodexBarTests/Presentation/TaskGlowTests.swift b/Tests/App/Presentation/TaskGlowTests.swift
similarity index 100%
rename from CodexBarTests/Presentation/TaskGlowTests.swift
rename to Tests/App/Presentation/TaskGlowTests.swift
diff --git a/CodexBarTests/Settings/GlobalHotKeySettingsTests.swift b/Tests/App/Settings/GlobalHotKeySettingsTests.swift
similarity index 100%
rename from CodexBarTests/Settings/GlobalHotKeySettingsTests.swift
rename to Tests/App/Settings/GlobalHotKeySettingsTests.swift
diff --git a/CodexBarTests/Settings/LoginItemSettingsTests.swift b/Tests/App/Settings/LoginItemSettingsTests.swift
similarity index 100%
rename from CodexBarTests/Settings/LoginItemSettingsTests.swift
rename to Tests/App/Settings/LoginItemSettingsTests.swift
diff --git a/CodexBarTests/Support/ActivityUpdateFixtures.swift b/Tests/App/Support/ActivityUpdateFixtures.swift
similarity index 100%
rename from CodexBarTests/Support/ActivityUpdateFixtures.swift
rename to Tests/App/Support/ActivityUpdateFixtures.swift
diff --git a/CodexBarTests/Support/BoundedProcessTests.swift b/Tests/App/Support/BoundedProcessTests.swift
similarity index 100%
rename from CodexBarTests/Support/BoundedProcessTests.swift
rename to Tests/App/Support/BoundedProcessTests.swift
diff --git a/CodexBarTests/Support/RefreshTaskCoordinatorTests.swift b/Tests/App/Support/RefreshTaskCoordinatorTests.swift
similarity index 100%
rename from CodexBarTests/Support/RefreshTaskCoordinatorTests.swift
rename to Tests/App/Support/RefreshTaskCoordinatorTests.swift
diff --git a/CodexBarTests/Support/SharedServerFixture.swift b/Tests/App/Support/SharedServerFixture.swift
similarity index 100%
rename from CodexBarTests/Support/SharedServerFixture.swift
rename to Tests/App/Support/SharedServerFixture.swift
diff --git a/CodexBarTests/Support/TestSupport.swift b/Tests/App/Support/TestSupport.swift
similarity index 100%
rename from CodexBarTests/Support/TestSupport.swift
rename to Tests/App/Support/TestSupport.swift
diff --git a/CodexBarTests/Sync/SyncAvailabilityTests.swift b/Tests/App/Sync/SyncAvailabilityTests.swift
similarity index 100%
rename from CodexBarTests/Sync/SyncAvailabilityTests.swift
rename to Tests/App/Sync/SyncAvailabilityTests.swift
diff --git a/CodexBarTests/Sync/SyncRecoveryTests.swift b/Tests/App/Sync/SyncRecoveryTests.swift
similarity index 100%
rename from CodexBarTests/Sync/SyncRecoveryTests.swift
rename to Tests/App/Sync/SyncRecoveryTests.swift
diff --git a/CodexBarTests/Sync/SyncSchedulerTests.swift b/Tests/App/Sync/SyncSchedulerTests.swift
similarity index 100%
rename from CodexBarTests/Sync/SyncSchedulerTests.swift
rename to Tests/App/Sync/SyncSchedulerTests.swift
diff --git a/CodexBarTests/Sync/ZoneRecoveryTests.swift b/Tests/App/Sync/ZoneRecoveryTests.swift
similarity index 100%
rename from CodexBarTests/Sync/ZoneRecoveryTests.swift
rename to Tests/App/Sync/ZoneRecoveryTests.swift
diff --git a/Tests/Helpers/Power/PowerHelperSleepTests.swift b/Tests/Helpers/Power/PowerHelperSleepTests.swift
new file mode 100644
index 0000000..b3ca873
--- /dev/null
+++ b/Tests/Helpers/Power/PowerHelperSleepTests.swift
@@ -0,0 +1,225 @@
+import Foundation
+import Synchronization
+import Testing
+
+@Suite(.timeLimit(.minutes(1)))
+struct PowerHelperSleepTests {
+ @Test func acquisitionPersistsOwnershipBeforeDisablingAndReleaseRestores() async throws {
+ let fixture = try PowerHelperFixture(disabled: false)
+ let acquired = await fixture.request(true, generation: 1)
+ #expect(acquired.exitCode == 0)
+ #expect(acquired.source == CodexBarSleepPreventionSource.codexBar.rawValue)
+ #expect(acquired.sleepDisabled)
+ #expect(fixture.store.record()?.state == .owned)
+ #expect(fixture.system.values.withLock { $0.ownershipAtWrite } == [.owned])
+
+ let released = await fixture.request(false, generation: 2)
+ #expect(released.exitCode == 0)
+ #expect(!released.sleepDisabled)
+ #expect(fixture.store.record()?.state == .idle)
+ #expect(fixture.system.values.withLock { $0.writes } == [true, false])
+ #expect(fixture.system.values.withLock { $0.ownershipAtWrite } == [.owned, .restoring])
+ }
+
+ @Test func externalSleepSettingIsNeitherClaimedNorRestored() async throws {
+ let fixture = try PowerHelperFixture(disabled: true)
+ let acquired = await fixture.request(true, generation: 1)
+ #expect(acquired.exitCode == 0)
+ #expect(acquired.source == CodexBarSleepPreventionSource.external.rawValue)
+ #expect(acquired.sleepDisabled)
+
+ let released = await fixture.request(false, generation: 2)
+ #expect(released.exitCode == 0)
+ #expect(released.sleepDisabled)
+ #expect(fixture.store.record()?.state == .idle)
+ #expect(fixture.store.values.withLock { $0.writes } == 0)
+ #expect(fixture.system.values.withLock { $0.writes }.isEmpty)
+ }
+
+ @Test(arguments: [false, true])
+ func ownedRequestOnlyReassertsSleepWhenNeeded(systemWasChanged: Bool) async throws {
+ let fixture = try await makeFixture(alreadyOwned: true)
+ let transaction = fixture.store.record()?.transaction
+ let persistedWrites = fixture.store.values.withLock { $0.writes }
+ fixture.system.values.withLock { $0.disabled = !systemWasChanged }
+
+ let result = await fixture.request(true, generation: 2)
+ #expect(result.exitCode == 0)
+ #expect(result.source == CodexBarSleepPreventionSource.codexBar.rawValue)
+ #expect(result.sleepDisabled)
+ #expect(fixture.store.record()?.transaction == transaction)
+ #expect(fixture.store.values.withLock { $0.writes } == persistedWrites)
+ #expect(fixture.system.values.withLock { $0.writes } == (systemWasChanged ? [true, true] : [true]))
+ }
+
+ @Test(arguments: [false, true], [Int32(-7), 0])
+ func unreadableSleepStateDoesNotTriggerWrites(alreadyOwned: Bool, exitCode: Int32) async throws {
+ let fixture = try await makeFixture(alreadyOwned: alreadyOwned)
+ let persistedWrites = fixture.store.values.withLock { $0.writes }
+ let systemWrites = fixture.system.values.withLock { $0.writes }
+ fixture.system.values.withLock { $0.scriptedReads = [(exitCode, nil)] }
+
+ let result = await fixture.request(true, generation: 2)
+ #expect(result.exitCode == (exitCode == 0 ? -1 : exitCode))
+ #expect(result.source == (alreadyOwned ? CodexBarSleepPreventionSource.codexBar : .none).rawValue)
+ #expect(!result.sleepDisabled)
+ #expect(fixture.store.values.withLock { $0.writes } == persistedWrites)
+ #expect(fixture.system.values.withLock { $0.writes } == systemWrites)
+ }
+
+ @Test(arguments: [false, true])
+ func failedInitialPersistenceDoesNotDisableSleepAndCanRetry(discardWrite: Bool) async throws {
+ let fixture = try PowerHelperFixture(disabled: false)
+ fixture.store.values.withLock {
+ $0.failWrite = !discardWrite
+ $0.discardsWrites = discardWrite
+ }
+ let failed = await fixture.request(true, generation: 1)
+ #expect(failed.exitCode == -1)
+ #expect(failed.source == CodexBarSleepPreventionSource.none.rawValue)
+ #expect(!failed.sleepDisabled)
+ #expect(fixture.store.record()?.state == .idle)
+ #expect(fixture.system.values.withLock { $0.writes }.isEmpty)
+
+ fixture.store.values.withLock {
+ $0.failWrite = false
+ $0.discardsWrites = false
+ }
+ #expect(await fixture.request(true, generation: 2).exitCode == 0)
+ #expect(fixture.system.values.withLock { $0.ownershipAtWrite } == [.owned])
+ }
+
+ @Test(arguments: [false, true])
+ func lostOwnedRecordIsRepairedBeforeAnySleepWrite(systemWasChanged: Bool) async throws {
+ let fixture = try await makeFixture(alreadyOwned: true)
+ let transaction = fixture.store.record()?.transaction
+ fixture.store.values.withLock { $0.data = Data() }
+ fixture.system.values.withLock { $0.disabled = !systemWasChanged }
+
+ let result = await fixture.request(true, generation: 2)
+ #expect(result.exitCode == 0)
+ #expect(result.sleepDisabled)
+ #expect(fixture.store.record()?.state == .owned)
+ #expect(fixture.store.record()?.transaction == transaction)
+ #expect(fixture.system.values.withLock { $0.writes } == (systemWasChanged ? [true, true] : [true]))
+ #expect(fixture.system.values.withLock { $0.ownershipAtWrite.allSatisfy { $0 == .owned } })
+ }
+
+ @Test func failedOwnedRecordRepairRestoresSleepBeforeReturningFailure() async throws {
+ let fixture = try await makeFixture(alreadyOwned: true)
+ fixture.store.values.withLock {
+ $0.data = Data()
+ $0.failedWriteStates = [.owned]
+ }
+ fixture.system.values.withLock { $0.disabled = false }
+
+ let result = await fixture.request(true, generation: 2)
+ #expect(result.exitCode == -1)
+ #expect(result.source == CodexBarSleepPreventionSource.codexBar.rawValue)
+ #expect(!result.sleepDisabled)
+ #expect(fixture.store.record()?.state == .idle)
+ #expect(fixture.system.values.withLock { $0.writes } == [true, false])
+ #expect(fixture.system.values.withLock { $0.ownershipAtWrite } == [.owned, .restoring])
+ }
+
+ @Test(arguments: [false, true])
+ func failedSystemWriteRetainsOwnershipForRelease(alreadyOwned: Bool) async throws {
+ let fixture = try await makeFixture(alreadyOwned: alreadyOwned)
+ fixture.system.values.withLock {
+ $0.disabled = false
+ $0.writeExitCode = -23
+ }
+ let reads = fixture.system.values.withLock { $0.reads }
+ let result = await fixture.request(true, generation: 2)
+ #expect(result.exitCode == -23)
+ #expect(result.source == CodexBarSleepPreventionSource.codexBar.rawValue)
+ #expect(!result.sleepDisabled)
+ #expect(fixture.store.record()?.state == .owned)
+ #expect(fixture.system.values.withLock { $0.reads } == reads + 1)
+
+ fixture.system.values.withLock { $0.writeExitCode = 0 }
+ #expect(await fixture.request(false, generation: 3).exitCode == 0)
+ #expect(fixture.store.record()?.state == .idle)
+ #expect(fixture.system.values.withLock { $0.writes.last } == false)
+ }
+
+ @Test(arguments: [false, true], [Int32(-9), 0])
+ func failedReadbackCannotReportSuccessfulSleepPrevention(alreadyOwned: Bool, exitCode: Int32) async throws {
+ let fixture = try await makeFixture(alreadyOwned: alreadyOwned)
+ fixture.system.values.withLock {
+ $0.disabled = false
+ $0.scriptedReads = [(0, false), (exitCode, nil)]
+ }
+ let result = await fixture.request(true, generation: 2)
+ #expect(result.exitCode == (exitCode == 0 ? -1 : exitCode))
+ #expect(result.source == CodexBarSleepPreventionSource.codexBar.rawValue)
+ #expect(!result.sleepDisabled)
+ #expect(fixture.store.record()?.state == .owned)
+ #expect(fixture.system.values.withLock { $0.disabled })
+ }
+
+ @Test(arguments: [false, true])
+ func unchangedSleepStateAfterWriteIsReportedAsFailure(alreadyOwned: Bool) async throws {
+ let fixture = try await makeFixture(alreadyOwned: alreadyOwned)
+ fixture.system.values.withLock {
+ $0.disabled = false
+ $0.ignoresWrites = true
+ }
+ let result = await fixture.request(true, generation: 2)
+ #expect(result.exitCode == -1)
+ #expect(result.source == CodexBarSleepPreventionSource.codexBar.rawValue)
+ #expect(!result.sleepDisabled)
+ #expect(fixture.store.record()?.state == .owned)
+ }
+
+ @Test(arguments: [false, true], [false, true])
+ func recordLostDuringSystemWriteIsRepairedOrSleepIsRestored(alreadyOwned: Bool, repairFails: Bool) async throws {
+ let fixture = try await makeFixture(alreadyOwned: alreadyOwned)
+ let store = fixture.store
+ fixture.system.values.withLock {
+ $0.disabled = false
+ $0.afterWrite = { disabled in
+ guard disabled else { return }
+ store.values.withLock {
+ $0.data = Data()
+ $0.failedWriteStates = repairFails ? [.owned] : []
+ }
+ }
+ }
+ let previousWrites = fixture.system.values.withLock { $0.writes }
+ let result = await fixture.request(true, generation: 2)
+ #expect(result.exitCode == (repairFails ? -1 : 0))
+ #expect(result.source == CodexBarSleepPreventionSource.codexBar.rawValue)
+ #expect(result.sleepDisabled == !repairFails)
+ #expect(fixture.store.record()?.state == (repairFails ? .idle : .owned))
+ #expect(fixture.system.values.withLock { $0.writes } == previousWrites + (repairFails ? [true, false] : [true]))
+ #expect(fixture.system.values.withLock { $0.ownershipAtWrite.last } == (repairFails ? .restoring : .owned))
+ }
+
+ @Test func pendingRestoreMustFinishBeforeAcquiringSleepAgain() async throws {
+ let fixture = try PowerHelperFixture(disabled: true, ownership: .owned, writeExitCode: -23)
+ let failed = await fixture.request(true, generation: 1)
+ #expect(failed.exitCode == -23)
+ #expect(failed.source == CodexBarSleepPreventionSource.codexBar.rawValue)
+ #expect(failed.sleepDisabled)
+ #expect(fixture.store.record()?.state == .restoring)
+ #expect(fixture.system.values.withLock { $0.writes } == [false, false])
+
+ fixture.system.values.withLock { $0.writeExitCode = 0 }
+ let retried = await fixture.request(true, generation: 2)
+ #expect(retried.exitCode == 0)
+ #expect(retried.sleepDisabled)
+ #expect(fixture.store.record()?.state == .owned)
+ #expect(fixture.system.values.withLock { $0.writes } == [false, false, false, true])
+ #expect(fixture.system.values.withLock { $0.ownershipAtWrite } == [.restoring, .restoring, .restoring, .owned])
+ }
+
+ private func makeFixture(alreadyOwned: Bool) async throws -> PowerHelperFixture {
+ let fixture = try PowerHelperFixture(disabled: false)
+ if alreadyOwned {
+ let acquired = await fixture.request(true, generation: 1)
+ try #require(acquired.exitCode == 0)
+ }
+ return fixture
+ }
+}
diff --git a/Tests/Helpers/Power/PowerHelperTestSupport.swift b/Tests/Helpers/Power/PowerHelperTestSupport.swift
new file mode 100644
index 0000000..df316ff
--- /dev/null
+++ b/Tests/Helpers/Power/PowerHelperTestSupport.swift
@@ -0,0 +1,146 @@
+import Foundation
+import Synchronization
+import Testing
+
+struct PowerHelperFixture {
+ struct SleepReply: Sendable {
+ let exitCode: Int32
+ let source: Int
+ let sleepDisabled: Bool
+ }
+
+ let store: MemoryOwnership
+ let system: FakeSleepSystem
+ let runtime: PowerHelperRuntime
+ let session: any CodexBarPowerHelperProtocol
+ let connection: TestConnection
+ let clientID = UUID().uuidString
+ let updateID = String(repeating: "a", count: 64)
+
+ init(disabled: Bool, ownership: SleepOwnership = .idle, writeExitCode: Int32 = 0) throws {
+ store = try MemoryOwnership(state: ownership)
+ system = FakeSleepSystem(disabled: disabled, writeExitCode: writeExitCode, store: store)
+ runtime = PowerHelperRuntime(ownershipStore: store, sleepOperations: system.operations)
+ runtime.recoverOwnershipAtStartup()
+ connection = TestConnection()
+ precondition(runtime.listener(NSXPCListener.anonymous(), shouldAcceptNewConnection: connection))
+ session = try #require(connection.exportedObject as? any CodexBarPowerHelperProtocol)
+ }
+
+ func update() async -> Int32 {
+ await withCheckedContinuation { continuation in
+ session.resetSleepAfterUpdate(updateID) { continuation.resume(returning: $0) }
+ }
+ }
+
+ func request(_ requested: Bool, generation: UInt64) async -> SleepReply {
+ await withCheckedContinuation { continuation in
+ session.setSleepPreventionRequested(requested, clientSessionID: clientID, generation: generation) { code, source, disabled in
+ continuation.resume(returning: SleepReply(exitCode: code, source: source, sleepDisabled: disabled))
+ }
+ }
+ }
+}
+
+final class TestConnection: NSXPCConnection, @unchecked Sendable {
+ override func resume() {}
+}
+
+final class MemoryOwnership: OwnershipStoring, Sendable {
+ struct State: Sendable {
+ var data: Data
+ var failWrite = false
+ var failedWriteStates = Set<SleepOwnership>()
+ var discardsWrites = false
+ var writes = 0
+ }
+
+ let url = URL(fileURLWithPath: "/unused-power-helper-test-state")
+ let values: Mutex<State>
+
+ init(state: SleepOwnership) throws {
+ let record = SleepOwnershipRecord(schema: 1, state: state, transaction: UUID(), identifier: nil, updated: Date())
+ let encoder = JSONEncoder()
+ encoder.dateEncodingStrategy = .iso8601
+ values = try Mutex(State(data: encoder.encode(record)))
+ }
+
+ func ensureOwnershipDirectory() throws {}
+
+ func writeOwnershipDataDurably(_ data: Data) throws {
+ let record = try #require(Self.decode(data))
+ try values.withLock {
+ if $0.failWrite || $0.failedWriteStates.contains(record.state) {
+ throw CocoaError(.fileWriteUnknown)
+ }
+ if !$0.discardsWrites {
+ $0.data = data
+ }
+ $0.writes += 1
+ }
+ }
+
+ func record() -> SleepOwnershipRecord? {
+ Self.decode(values.withLock { $0.data })
+ }
+
+ func ownershipRecordState() -> OwnershipRecordState {
+ record().map(OwnershipRecordState.present) ?? .absent
+ }
+
+ private static func decode(_ data: Data) -> SleepOwnershipRecord? {
+ let decoder = JSONDecoder()
+ decoder.dateDecodingStrategy = .iso8601
+ return try? decoder.decode(SleepOwnershipRecord.self, from: data)
+ }
+}
+
+final class FakeSleepSystem: Sendable {
+ struct State: Sendable {
+ var disabled: Bool
+ var writeExitCode: Int32
+ var readExitCode: Int32 = 0
+ var scriptedReads: [(exitCode: Int32, value: Bool?)] = []
+ var ignoresWrites = false
+ var afterWrite: (@Sendable (Bool) -> Void)?
+ var reads = 0
+ var writes: [Bool] = []
+ var ownershipAtWrite: [SleepOwnership?] = []
+ }
+
+ let values: Mutex<State>
+ private let store: MemoryOwnership
+
+ init(disabled: Bool, writeExitCode: Int32, store: MemoryOwnership) {
+ values = Mutex(State(disabled: disabled, writeExitCode: writeExitCode))
+ self.store = store
+ }
+
+ var operations: PowerHelperSleepOperations {
+ PowerHelperSleepOperations(read: { [self] in
+ values.withLock {
+ $0.reads += 1
+ if !$0.scriptedReads.isEmpty {
+ let read = $0.scriptedReads.removeFirst()
+ return (PmsetResult(exitCode: read.exitCode, output: ""), read.value)
+ }
+ return (PmsetResult(exitCode: $0.readExitCode, output: ""), $0.readExitCode == 0 ? $0.disabled : nil)
+ }
+ }, write: { [self] disabled in
+ let ownership = store.record()?.state
+ let result = values.withLock { state -> (Int32, (@Sendable (Bool) -> Void)?) in
+ state.writes.append(disabled)
+ state.ownershipAtWrite.append(ownership)
+ guard state.writeExitCode == 0 else {
+ return (state.writeExitCode, nil)
+ }
+ if !state.ignoresWrites {
+ state.disabled = disabled
+ }
+ return (0, state.afterWrite)
+ }
+ result.1?(disabled)
+ return PmsetResult(exitCode: result.0, output: "")
+ })
+ }
+}
diff --git a/Tests/Helpers/Power/PowerHelperUpdateTests.swift b/Tests/Helpers/Power/PowerHelperUpdateTests.swift
new file mode 100644
index 0000000..cac1cab
--- /dev/null
+++ b/Tests/Helpers/Power/PowerHelperUpdateTests.swift
@@ -0,0 +1,61 @@
+import Foundation
+import Synchronization
+import Testing
+
+@Suite(.timeLimit(.minutes(1)))
+struct PowerHelperUpdateTests {
+ @Test func updatePreservesExternalSleepSetting() async throws {
+ let fixture = try PowerHelperFixture(disabled: true)
+ #expect(await fixture.update() == 0)
+ #expect(fixture.system.values.withLock { $0.writes } == [])
+ #expect(fixture.store.record()?.state == .idle)
+ #expect(fixture.store.record()?.identifier == fixture.updateID)
+ }
+
+ @Test func updateKeepsLiveLeaseAndReleaseStillRestoresSleep() async throws {
+ let fixture = try PowerHelperFixture(disabled: false)
+ #expect(await fixture.request(true, generation: 1).exitCode == 0)
+ #expect(fixture.system.values.withLock { $0.disabled })
+ #expect(await fixture.update() == 0)
+ #expect(fixture.store.record()?.state == .owned)
+ #expect(fixture.system.values.withLock { $0.writes } == [true])
+ #expect(await fixture.request(false, generation: 2).exitCode == 0)
+ #expect(fixture.system.values.withLock { $0.writes } == [true, false])
+ #expect(fixture.store.record()?.state == .idle)
+ }
+
+ @Test func updateRetriesUnfinishedOwnedRecovery() async throws {
+ let fixture = try PowerHelperFixture(disabled: true, ownership: .owned, writeExitCode: -1)
+ #expect(fixture.store.record()?.state == .restoring)
+ #expect(await fixture.update() != 0)
+ #expect(fixture.store.record()?.identifier == nil)
+ fixture.system.values.withLock { $0.writeExitCode = 0 }
+ #expect(await fixture.update() == 0)
+ #expect(!fixture.system.values.withLock { $0.disabled })
+ #expect(fixture.store.record()?.state == .idle)
+ #expect(fixture.store.record()?.identifier == fixture.updateID)
+ }
+
+ @Test func failedPersistenceDoesNotConsumeUpdateIdentifier() async throws {
+ let fixture = try PowerHelperFixture(disabled: true)
+ fixture.store.values.withLock { $0.failWrite = true }
+ #expect(await fixture.update() != 0)
+ #expect(fixture.store.record()?.identifier == nil)
+ fixture.store.values.withLock { $0.failWrite = false }
+ #expect(await fixture.update() == 0)
+ let writes = fixture.store.values.withLock { $0.writes }
+ #expect(await fixture.update() == 0)
+ #expect(fixture.store.values.withLock { $0.writes } == writes)
+ #expect(fixture.system.values.withLock { $0.writes }.isEmpty)
+ }
+
+ @Test func failedReadCannotCompleteUpdate() async throws {
+ let fixture = try PowerHelperFixture(disabled: true)
+ fixture.system.values.withLock { $0.readExitCode = -1 }
+ #expect(await fixture.update() != 0)
+ #expect(fixture.store.record()?.identifier == nil)
+ fixture.system.values.withLock { $0.readExitCode = 0 }
+ #expect(await fixture.update() == 0)
+ #expect(fixture.system.values.withLock { $0.writes }.isEmpty)
+ }
+}