dsh-clamawake 0.0.0-stage → 0.1.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +21 -0
- package/NOTICE +13 -0
- package/README.md +94 -2
- package/bin/ENGINE-FINGERPRINT +5 -0
- package/bin/vd-engine +0 -0
- package/cordis.patch.yml +4 -0
- package/index.js +395 -0
- package/locale/en.json +6 -0
- package/locale/zh.json +6 -0
- package/package.json +53 -4
package/LICENSE
ADDED
|
@@ -0,0 +1,21 @@
|
|
|
1
|
+
MIT License
|
|
2
|
+
|
|
3
|
+
Copyright (c) 2026 zhangweijian97
|
|
4
|
+
|
|
5
|
+
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
6
|
+
of this software and associated documentation files (the "Software"), to deal
|
|
7
|
+
in the Software without restriction, including without limitation the rights
|
|
8
|
+
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
9
|
+
copies of the Software, and to permit persons to whom the Software is
|
|
10
|
+
furnished to do so, subject to the following conditions:
|
|
11
|
+
|
|
12
|
+
The above copyright notice and this permission notice shall be included in all
|
|
13
|
+
copies or substantial portions of the Software.
|
|
14
|
+
|
|
15
|
+
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
16
|
+
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
17
|
+
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
18
|
+
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
19
|
+
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
20
|
+
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
21
|
+
SOFTWARE.
|
package/NOTICE
ADDED
|
@@ -0,0 +1,13 @@
|
|
|
1
|
+
dsh-clamawake
|
|
2
|
+
Copyright (c) 2026 zhangweijian97
|
|
3
|
+
|
|
4
|
+
This package bundles the ClamAwake engine binary at bin/vd-engine.
|
|
5
|
+
|
|
6
|
+
That binary is part of ClamAwake, which is licensed under the GNU General
|
|
7
|
+
Public License v3.0 (GPL-3.0):
|
|
8
|
+
|
|
9
|
+
- Source: https://github.com/zhangweijian97/ClamAwake
|
|
10
|
+
- License text: https://www.gnu.org/licenses/gpl-3.0.html
|
|
11
|
+
|
|
12
|
+
The plugin's own JavaScript source is MIT-licensed (see LICENSE). The bundled
|
|
13
|
+
engine remains GPL-3.0; the corresponding source is available at the URL above.
|
package/README.md
CHANGED
|
@@ -1,3 +1,95 @@
|
|
|
1
|
-
#
|
|
1
|
+
# dsh-clamawake(ClamAwake 的 DSH 插件)
|
|
2
2
|
|
|
3
|
-
|
|
3
|
+
把 ClamAwake 的合盖保活配方绑到 DSH 宿主生命周期上:**DSH 启动 = 保活在跑,DSH 停止 = 保活停**。没有 web 面板(无 UI 需求),纯宿主半边的后台插件。
|
|
4
|
+
|
|
5
|
+
**前置条件**:macOS(Apple Silicon)。插件**自包含**——`bin/vd-engine` 随包分发,不需要单独安装 ClamAwake。
|
|
6
|
+
|
|
7
|
+
保活配方两件套(与 ClamAwake 应用同一配方):
|
|
8
|
+
|
|
9
|
+
1. **虚拟屏**:spawn `vd-engine create 1800 1169 --hidpi --hold --mirror-main` 子进程持有屏——虚拟屏活在持有进程的生命周期内(CGVirtualDisplay 没有跨进程销毁 API,见 ClamAwake 仓 `src/vd-engine.swift` 的结论注释);对子进程 SIGTERM → 引擎的 signal handler `exit(0)` → 屏随之消失。`--mirror-main` 与应用版同参:每次宿主启动=新进程=新建屏,镜像基线不会自动回来,必须启动即自挂主屏镜像;不带它是扩展屏,合盖后不是镜像接管。
|
|
10
|
+
2. **`caffeinate -d` 显示断言**:独立子进程,停止时一并 SIGTERM。
|
|
11
|
+
|
|
12
|
+
## 生命周期语义
|
|
13
|
+
|
|
14
|
+
| 阶段 | 动作 |
|
|
15
|
+
|---|---|
|
|
16
|
+
| 插件 start(`apply` → `ctx.effect` setup) | 解析引擎二进制 → 核对 `/usr/bin/caffeinate` 存在 → 跑一次只读 `vd-engine list` → **已有 `kya=yes` 的屏则复用不重建**(判据与 `vd-engine doctor` 的 `keepalive_running` 同源:KYA vendor 标记 `0x4B5941`)→ 否则 spawn 建屏子进程 + caffeinate 子进程,异步尾段读回屏 id 并再 list 一遍交叉核验(执行后验证,不信子进程一面之词) |
|
|
17
|
+
| 插件 dispose(`ctx.effect` 的 disposer) | **只 SIGTERM 自己 spawn 的子进程**(引擎建屏子进程 + caffeinate),3s 未退升级 SIGKILL 兜底;屏随引擎子进程退出消失 |
|
|
18
|
+
|
|
19
|
+
**所有权边界(安全红线)**:复用的外部屏(别的 vd-engine 进程 / 菜单栏壳 / 其他虚拟屏工具持有)**绝不动**——本插件 dispose 不碰任何不是自己 spawn 的进程。引擎子进程意外退出时打显著日志并自动重启(退避 1s 起、每次翻倍、30s 封顶;caffeinate 断言独立保留)。
|
|
20
|
+
|
|
21
|
+
**日志**:`console.log` 前缀 `[clamawake]`,进宿主控制台输出(启动/复用/建屏/核验/停止各一行,失败带原因)。
|
|
22
|
+
|
|
23
|
+
## 环境变量
|
|
24
|
+
|
|
25
|
+
| 变量 | 语义 | 默认 |
|
|
26
|
+
|---|---|---|
|
|
27
|
+
| `CLAMAWAKE_ENGINE` | vd-engine 可执行文件的绝对路径(解析链第 1 级) | 未设 |
|
|
28
|
+
| `CLAMAWAKE_REUSE` | 设 `0`/`false`/`no` 强制走建屏路径(测试逃生阀;生产不要设) | 复用开启 |
|
|
29
|
+
|
|
30
|
+
## 引擎二进制怎么来
|
|
31
|
+
|
|
32
|
+
插件包里带 `bin/vd-engine`(arm64),装完即可用,不需要另外安装 ClamAwake。引擎来自 [ClamAwake](https://github.com/zhangweijian97/ClamAwake) 的 `src/vd-engine.swift`,按包发布版本锁定——升级引擎=发新版插件。
|
|
33
|
+
|
|
34
|
+
解析链(第一个存在且可执行的生效):
|
|
35
|
+
|
|
36
|
+
1. 环境变量 `CLAMAWAKE_ENGINE`(绝对路径,用于本机调试或替换引擎);
|
|
37
|
+
2. `<插件目录>/bin/vd-engine` —— **随包分发的引擎**(主路径);
|
|
38
|
+
3. `/Applications/ClamAwake.app/Contents/Resources/vd-engine` 等已安装应用的兜底位(本机开发便利,非必需)。
|
|
39
|
+
|
|
40
|
+
重新产出包内引擎(发布前必跑,禁止手工拷贝——手工拷贝是引擎漂移的来源):
|
|
41
|
+
|
|
42
|
+
```sh
|
|
43
|
+
scripts/build-engine.sh # 从兄弟仓 ../ClamAwake 的源码编译
|
|
44
|
+
scripts/build-engine.sh --copy # 从已安装的 ClamAwake.app 复制
|
|
45
|
+
```
|
|
46
|
+
|
|
47
|
+
## 许可证
|
|
48
|
+
|
|
49
|
+
插件 JavaScript 源码为 MIT(见 `LICENSE`)。`bin/vd-engine` 属于 ClamAwake,**GPL-3.0**——对应源码在 <https://github.com/zhangweijian97/ClamAwake>(见 `NOTICE`)。
|
|
50
|
+
|
|
51
|
+
## 装载步骤(插件管理器路径已实测,见「已知边界」)
|
|
52
|
+
|
|
53
|
+
1. 无需预装应用——引擎在包里。
|
|
54
|
+
2. 把本目录作为插件包装进 DSH,两种等价路径:
|
|
55
|
+
- **界面/插件管理器**:`plugin_manager(action=install_bundle, target=<本目录绝对路径>)`(装成的是 profile 下指向本目录的 link,改代码后重新启用即可生效,无需拷贝);
|
|
56
|
+
- **文件级**(DSH 插件接入的硬约束:必须是 profile 下**实体目录** + 双登记):把本目录拷到 `~/.dsh/profiles/<profile>/node_modules/dsh-clamawake/`,并在该 profile 的 `package.json` 里同时登记 `dependencies` 与 `dsh.profile.bundles`。手工符号链接不要用——宿主 import 会失败且只打一行「entry did not activate」;插件管理器的 link 依赖不同,已实测可用。
|
|
57
|
+
3. **重启 DSH**(插件只在应用启动时加载;已装好后改代码,重新启用插件(`set_plugin` 关→开)即可让宿主读到新模块)。
|
|
58
|
+
4. 验证:宿主控制台出现 `[clamawake]` 启动日志(复用或建屏 + 核验通过);`vd-engine list` 里出现 `kya=yes` 屏(若此前没有的话);退出 DSH 后该屏消失、本插件挂的 caffeinate 断言释放。
|
|
59
|
+
5. 移除/更新插件:`remove_bundle`(或文件级删除 + 重启);更新 `index.js` 后需重装并重启。
|
|
60
|
+
|
|
61
|
+
`package.json` 的 `dsh` 段只有 `bundle.patch`(指向 `cordis.patch.yml`,往宿主 bundle 插一行 `dsh-clamawake`)——没有 `dsh.client` 段(无 web 面板、无客户端模块)。
|
|
62
|
+
|
|
63
|
+
## 结构
|
|
64
|
+
|
|
65
|
+
| 文件 | 作用 |
|
|
66
|
+
|---|---|
|
|
67
|
+
| `index.js` | 宿主半边:start/dispose 生命周期、引擎解析、复用防护、交叉核验、崩溃重启。无 npm 依赖(`node:child_process`,数组参数不经 shell) |
|
|
68
|
+
| `bin/vd-engine` | 随包分发的引擎二进制(arm64;GPL-3.0,见 `NOTICE`) |
|
|
69
|
+
| `scripts/build-engine.sh` | 产出包内引擎:从 ClamAwake 源码编译,或从已安装应用复制 |
|
|
70
|
+
| `NOTICE` | 引擎二进制的来源与 GPL-3.0 声明 |
|
|
71
|
+
| `cordis.patch.yml` | bundle patch:插入一行 `dsh-clamawake`(仅宿主半边) |
|
|
72
|
+
| `locale/zh.json` / `locale/en.json` | Plugin Manager 读的标题/描述 |
|
|
73
|
+
| `test-lifecycle.mjs` | 生命周期自测(不经宿主,见下) |
|
|
74
|
+
|
|
75
|
+
## 自测
|
|
76
|
+
|
|
77
|
+
```sh
|
|
78
|
+
node test-lifecycle.mjs
|
|
79
|
+
```
|
|
80
|
+
|
|
81
|
+
模拟 cordis 装载协议(最小 ctx:`effect(setup)` → setup 同步执行、返回值当 disposer),两个阶段:
|
|
82
|
+
|
|
83
|
+
- **阶段 A 建屏路径**(`CLAMAWAKE_REUSE=0`):start → `vd-engine list` 出现新的 kya=yes 屏 → dispose → 屏消失;
|
|
84
|
+
- **阶段 B 复用路径**(默认):start → 不建新屏、复用既有 kya=yes 屏 → dispose → 既有屏原样;
|
|
85
|
+
- **终态复核**:在线屏集合与测试开始时一致。
|
|
86
|
+
|
|
87
|
+
引擎按解析链取(已装的应用 / `bin/vd-engine` / `CLAMAWAKE_ENGINE`);本机开发可先把 ClamAwake 仓构建产物拷进 `bin/`(不入库)。**安全边界**:脚本全程只读查询 + 只 SIGTERM 自己 spawn 的子进程,绝不 kill 外部保活引擎、绝不跨进程 remove 任何屏。
|
|
88
|
+
|
|
89
|
+
## 已知边界
|
|
90
|
+
|
|
91
|
+
- **无 Config 导出**:配置只走环境变量(与 dsh-member/spacemgr 一致,无 UI 场景够用)。
|
|
92
|
+
- **引擎意外退出自动重启(2026-11-08)**:子进程 exit 触发退避重启(1s 起、每次翻倍、30s 封顶),成功建屏后轮次归零;插件停止时清掉待执行的定时器,不再拉起。实测 `kill -9` 引擎后约 1s 恢复新屏,caffeinate 不断。
|
|
93
|
+
- **真实 DSH 宿主装载已验收(2026-11-08)**:`install_bundle` 装载并在宿主激活(`application: applied`);复用模式下挂自有 `caffeinate -d`、不动外部 kya=yes 屏;`set_plugin` 关闭只收自有 caffeinate(用户 ClamAwake.app 保活与外部屏原样),重新开启重挂。协议级自测(`node test-lifecycle.mjs`)同一轮通过:建屏 → 核验 → 拆屏 → 屏消失,复用路径不重复建屏、终态与基线一致。
|
|
94
|
+
- **宿主被强杀时的孤儿子进程(未验证)**:正常退出走 cordis dispose(SIGTERM 自有子进程);若宿主进程被 `kill -9` 之类强杀,dispose 不执行,插件 spawn 的 vd-engine / caffeinate 可能成孤儿继续保活,需手动 `kill`(下次宿主启动时插件会按 kya 标记复用该屏)。
|
|
95
|
+
- **GUI 宿主的环境变量缺口**:见「引擎二进制怎么来」——发布形态用应用安装位定位,本机开发用 `bin/vd-engine` 或 `CLAMAWAKE_ENGINE`。
|
package/bin/vd-engine
ADDED
|
Binary file
|
package/cordis.patch.yml
ADDED
package/index.js
ADDED
|
@@ -0,0 +1,395 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* dsh-clamawake —— ClamAwake 合盖保活与 DSH 宿主生命周期的绑定(宿主半边)。
|
|
3
|
+
*
|
|
4
|
+
* 绑定语义:DSH 起来 = 保活配方在跑;DSH 停 = 配方停。配方两件套
|
|
5
|
+
* (见仓 README「快速上手」):
|
|
6
|
+
*
|
|
7
|
+
* 1. 虚拟屏:spawn `vd-engine create 1800 1169 --hidpi --hold --mirror-main`
|
|
8
|
+
* 子进程持有屏——屏活在该子进程生命周期内(CGVirtualDisplay 无跨进程销毁 API,
|
|
9
|
+
* 见 src/vd-engine.swift remove 子命令的结论注释);给子进程 SIGTERM → 引擎的
|
|
10
|
+
* signal handler exit(0) → 屏随之消失。`--mirror-main` 与应用版
|
|
11
|
+
* (shell/Sources/ClamAwake/EngineController.swift)同参:每次宿主启动=新进程=
|
|
12
|
+
* 新建屏,镜像基线不会自动回来(vd-engine 用法说明的 launchd/自启形态同判),
|
|
13
|
+
* 必须启动即自挂主屏镜像;否则建出来的是扩展屏,合盖后不是镜像接管。
|
|
14
|
+
* 2. caffeinate -d 显示断言:独立子进程,停止时一并 SIGTERM。
|
|
15
|
+
*
|
|
16
|
+
* 重复启动防护(判据与 `vd-engine doctor` 的 keepalive_running 同源):
|
|
17
|
+
* start 时先跑一次只读 `vd-engine list`,已有 kya=yes 的屏(本引擎的 KYA vendor 标记)
|
|
18
|
+
* 就复用、不重建。所有权边界(安全红线):复用的屏持有者不属于本插件(别的 vd-engine
|
|
19
|
+
* 进程 / 菜单栏壳 / 其他虚拟屏工具),本插件 dispose 时绝不动它们——停止动作只落在
|
|
20
|
+
* 自己 spawn 的子进程上。
|
|
21
|
+
*
|
|
22
|
+
* 测试逃生阀:CLAMAWAKE_REUSE=0(或 false)强制走建屏路径——本机常驻保活屏会被
|
|
23
|
+
* 默认复用逻辑命中,test-lifecycle.mjs 用它验证「建→拆」全链路。
|
|
24
|
+
*
|
|
25
|
+
* 引擎二进制解析(第一个存在且可执行的生效,详见 README):
|
|
26
|
+
* 1. 环境变量 CLAMAWAKE_ENGINE(绝对路径;本机调试或替换引擎用)
|
|
27
|
+
* 2. <插件目录>/bin/vd-engine (随包分发的引擎,自包含的主路径)
|
|
28
|
+
* 3. /Applications/ClamAwake.app/Contents/Resources/vd-engine(已装应用的兜底位)
|
|
29
|
+
* 4. ~/Applications/ClamAwake.app/Contents/Resources/vd-engine(用户目录安装位)
|
|
30
|
+
* 全部落空 → 抛明确错误:列尝试过的路径 + 引擎来源说明。
|
|
31
|
+
*
|
|
32
|
+
* 没有 npm 依赖:node:child_process 的 spawn / spawnSync,数组参数不经 shell。
|
|
33
|
+
*
|
|
34
|
+
* 状态暴露:cordis 把 apply 的返回值当 effect 处理(普通对象直接报 TypeError: Invalid effect),
|
|
35
|
+
* 所以 apply 不返回 state;最近一次启动的 state 经 getState() 提供(test-lifecycle.mjs 消费)。
|
|
36
|
+
*/
|
|
37
|
+
import { spawn, spawnSync } from 'node:child_process'
|
|
38
|
+
import fs from 'node:fs'
|
|
39
|
+
import path from 'node:path'
|
|
40
|
+
import { fileURLToPath } from 'node:url'
|
|
41
|
+
|
|
42
|
+
const VERSION = '0.1.1'
|
|
43
|
+
const LOG = '[clamawake]'
|
|
44
|
+
|
|
45
|
+
// 保活配方固定参数:常见 MacBook 内屏逻辑分辨率(1800x1169,HiDPI 像素 3600x2338)
|
|
46
|
+
const SCREEN_W = 1800
|
|
47
|
+
const SCREEN_H = 1169
|
|
48
|
+
|
|
49
|
+
const CAFFEINATE = '/usr/bin/caffeinate'
|
|
50
|
+
const LIST_TIMEOUT_MS = 5000 // 只读 list 的一次性上限
|
|
51
|
+
const CREATE_ID_TIMEOUT_MS = 10000 // 引擎自己最多等 3s WindowServer,留足余量
|
|
52
|
+
const KILL_GRACE_MS = 3000 // dispose 的 SIGTERM 升级 SIGKILL 的宽限
|
|
53
|
+
const RESTART_BASE_MS = 1000 // 引擎意外退出后的重启退避:1s 起、每次翻倍
|
|
54
|
+
const RESTART_MAX_MS = 30000 // 退避封顶
|
|
55
|
+
|
|
56
|
+
const PLUGIN_DIR = path.dirname(fileURLToPath(import.meta.url))
|
|
57
|
+
|
|
58
|
+
// MARK: - 引擎定位
|
|
59
|
+
|
|
60
|
+
function engineCandidates() {
|
|
61
|
+
const list = []
|
|
62
|
+
const envPath = String(process.env.CLAMAWAKE_ENGINE || '').trim()
|
|
63
|
+
if (envPath) list.push(envPath)
|
|
64
|
+
list.push(
|
|
65
|
+
path.join(PLUGIN_DIR, 'bin', 'vd-engine'),
|
|
66
|
+
'/Applications/ClamAwake.app/Contents/Resources/vd-engine',
|
|
67
|
+
path.join(process.env.HOME || '', 'Applications', 'ClamAwake.app', 'Contents', 'Resources', 'vd-engine'),
|
|
68
|
+
)
|
|
69
|
+
return list
|
|
70
|
+
}
|
|
71
|
+
|
|
72
|
+
/** 返回 { engine };全部落空则抛错(列尝试路径 + 构建命令,不给静默降级)。 */
|
|
73
|
+
function resolveEngine() {
|
|
74
|
+
const tried = []
|
|
75
|
+
for (const candidate of engineCandidates()) {
|
|
76
|
+
try {
|
|
77
|
+
fs.accessSync(candidate, fs.constants.X_OK)
|
|
78
|
+
return { engine: candidate, tried }
|
|
79
|
+
} catch {
|
|
80
|
+
tried.push(candidate)
|
|
81
|
+
}
|
|
82
|
+
}
|
|
83
|
+
throw new Error([
|
|
84
|
+
`${LOG} 找不到 vd-engine 可执行文件,依次尝试过:`,
|
|
85
|
+
...tried.map((p) => `${LOG} · ${p}`),
|
|
86
|
+
`${LOG} 修复办法(任选一):`,
|
|
87
|
+
`${LOG} 1. 仓根编译:swiftc -O src/vd-engine.swift -o vd-engine(落点即候选 3);`,
|
|
88
|
+
`${LOG} 2. 设环境变量 CLAMAWAKE_ENGINE 指向已有的 vd-engine 绝对路径(GUI 宿主需 launchctl setenv,见 README);`,
|
|
89
|
+
`${LOG} 3. 把编译产物拷进 <插件目录>/bin/vd-engine(自包含安装)。`,
|
|
90
|
+
].join('\n'))
|
|
91
|
+
}
|
|
92
|
+
|
|
93
|
+
/** 读引擎自报版本(vd-engine version);旧引擎没有该子命令时降级为不可知,不阻断启动。 */
|
|
94
|
+
function describeEngine(engine) {
|
|
95
|
+
let run
|
|
96
|
+
try {
|
|
97
|
+
run = spawnSync(engine, ['version'], { encoding: 'utf8', timeout: LIST_TIMEOUT_MS })
|
|
98
|
+
} catch (error) {
|
|
99
|
+
return { label: `版本读取失败(${error.message})` }
|
|
100
|
+
}
|
|
101
|
+
if (run.error || run.status !== 0) {
|
|
102
|
+
return { label: '版本不可知(引擎没有 version 子命令,可能是旧版)' }
|
|
103
|
+
}
|
|
104
|
+
const version = /^version=(.+)$/m.exec(String(run.stdout || ''))?.[1]?.trim() ?? 'unknown'
|
|
105
|
+
const arch = /^arch=(.+)$/m.exec(String(run.stdout || ''))?.[1]?.trim() ?? 'unknown'
|
|
106
|
+
return { version, arch, label: `${version} (${arch})` }
|
|
107
|
+
}
|
|
108
|
+
|
|
109
|
+
/**
|
|
110
|
+
* 与包内指纹(bin/ENGINE-FINGERPRINT,构建脚本产出)比对:应用版与插件版的引擎不同步时打 warn。
|
|
111
|
+
* 只提示不阻断——版本不符时保活配方仍然可用,只是行为可能与应用版不一致。
|
|
112
|
+
*/
|
|
113
|
+
function checkEngineFingerprint(engine, info) {
|
|
114
|
+
const fpPath = path.join(PLUGIN_DIR, 'bin', 'ENGINE-FINGERPRINT')
|
|
115
|
+
let fp
|
|
116
|
+
try {
|
|
117
|
+
fp = fs.readFileSync(fpPath, 'utf8')
|
|
118
|
+
} catch {
|
|
119
|
+
return
|
|
120
|
+
}
|
|
121
|
+
const expected = /^version=(.+)$/m.exec(fp)?.[1]?.trim()
|
|
122
|
+
if (expected && info.version && expected !== info.version) {
|
|
123
|
+
console.warn(`${LOG} 引擎版本与包内指纹不符:包内 ${expected},实际 ${info.version}`
|
|
124
|
+
+ `(引擎被替换过,或包未按 scripts/build-engine.sh 重建)`)
|
|
125
|
+
}
|
|
126
|
+
}
|
|
127
|
+
|
|
128
|
+
// MARK: - 引擎只读读数
|
|
129
|
+
|
|
130
|
+
/**
|
|
131
|
+
* 跑一次 `vd-engine list`,解析出行 [{ id, kya }]。
|
|
132
|
+
* list 的行形如 `id=20 main=no ... vendor=4938049 ... kya=yes`;kya=yes 即本引擎
|
|
133
|
+
* KYA vendor 标记(0x4B5941),与 doctor 的 keepalive_running 判据同源。
|
|
134
|
+
* 退出码非 0 / 超时 / 一行都解析不出 → 抛错(不猜)。
|
|
135
|
+
*/
|
|
136
|
+
function listScreens(engine) {
|
|
137
|
+
const run = spawnSync(engine, ['list'], { encoding: 'utf8', timeout: LIST_TIMEOUT_MS })
|
|
138
|
+
if (run.error) throw new Error(`${LOG} vd-engine list 执行失败:${run.error.message}`)
|
|
139
|
+
if (run.status !== 0) {
|
|
140
|
+
throw new Error(`${LOG} vd-engine list 退出码 ${run.status}:${String(run.stderr || '').trim()}`)
|
|
141
|
+
}
|
|
142
|
+
const screens = []
|
|
143
|
+
for (const line of String(run.stdout || '').split('\n')) {
|
|
144
|
+
const m = line.match(/^id=(\d+)\b.*\bkya=(yes|no)\b/)
|
|
145
|
+
if (m) screens.push({ id: Number(m[1]), kya: m[2] === 'yes' })
|
|
146
|
+
}
|
|
147
|
+
if (!screens.length) {
|
|
148
|
+
throw new Error(`${LOG} vd-engine list 输出解析不出任何显示器行,输出原文:\n${run.stdout}`)
|
|
149
|
+
}
|
|
150
|
+
return screens
|
|
151
|
+
}
|
|
152
|
+
|
|
153
|
+
// MARK: - 子进程动作
|
|
154
|
+
|
|
155
|
+
/**
|
|
156
|
+
* spawn 建屏子进程(create --hold),返回 { child, screenIdPromise }。
|
|
157
|
+
* 引擎先建屏、stdout 打印屏 id、随后常驻持有;这里不阻塞 apply——id 的到达在
|
|
158
|
+
* 异步尾段确认(确认成功/失败都打日志),dispose 在 id 到达前触发也能正确收场
|
|
159
|
+
* (SIGTERM 让引擎退出,屏未建或随进程消失)。
|
|
160
|
+
*/
|
|
161
|
+
function spawnEngineCreate(engine) {
|
|
162
|
+
const child = spawn(engine, ['create', String(SCREEN_W), String(SCREEN_H), '--hidpi', '--hold', '--mirror-main'], {
|
|
163
|
+
stdio: ['ignore', 'pipe', 'pipe'],
|
|
164
|
+
})
|
|
165
|
+
const screenIdPromise = new Promise((resolve, reject) => {
|
|
166
|
+
let stdoutBuf = ''
|
|
167
|
+
let stderrTail = ''
|
|
168
|
+
let settled = false
|
|
169
|
+
const timer = setTimeout(() => {
|
|
170
|
+
if (settled) return
|
|
171
|
+
settled = true
|
|
172
|
+
try { child.kill('SIGTERM') } catch {}
|
|
173
|
+
reject(new Error(`${CREATE_ID_TIMEOUT_MS}ms 内没从引擎 stdout 读到屏 id。${stderrTail}`))
|
|
174
|
+
}, CREATE_ID_TIMEOUT_MS)
|
|
175
|
+
if (timer.unref) timer.unref()
|
|
176
|
+
|
|
177
|
+
child.stdout.setEncoding('utf8')
|
|
178
|
+
child.stdout.on('data', (chunk) => {
|
|
179
|
+
if (settled) return
|
|
180
|
+
stdoutBuf += chunk
|
|
181
|
+
const nl = stdoutBuf.indexOf('\n')
|
|
182
|
+
if (nl === -1) return
|
|
183
|
+
settled = true
|
|
184
|
+
clearTimeout(timer)
|
|
185
|
+
const id = Number(stdoutBuf.slice(0, nl).trim())
|
|
186
|
+
if (Number.isInteger(id) && id > 0) {
|
|
187
|
+
resolve({ screenId: id })
|
|
188
|
+
} else {
|
|
189
|
+
reject(new Error(`引擎 stdout 首行不是屏 id:${JSON.stringify(stdoutBuf.slice(0, nl))}`))
|
|
190
|
+
}
|
|
191
|
+
})
|
|
192
|
+
child.stderr.setEncoding('utf8')
|
|
193
|
+
child.stderr.on('data', (chunk) => {
|
|
194
|
+
// 只留尾部供报错引用,不逐行转发(--hold 期的诊断行会太吵)
|
|
195
|
+
stderrTail = (stderrTail + chunk).slice(-800)
|
|
196
|
+
})
|
|
197
|
+
child.on('error', (error) => {
|
|
198
|
+
if (settled) return
|
|
199
|
+
settled = true
|
|
200
|
+
clearTimeout(timer)
|
|
201
|
+
reject(new Error(`引擎子进程启动失败:${error.message}`))
|
|
202
|
+
})
|
|
203
|
+
child.on('exit', (code, signal) => {
|
|
204
|
+
if (settled) return
|
|
205
|
+
settled = true
|
|
206
|
+
clearTimeout(timer)
|
|
207
|
+
reject(new Error(`引擎子进程在建屏阶段提前退出(code=${code} signal=${signal})。${stderrTail}`))
|
|
208
|
+
})
|
|
209
|
+
})
|
|
210
|
+
return { child, screenIdPromise }
|
|
211
|
+
}
|
|
212
|
+
|
|
213
|
+
function spawnCaffeinate() {
|
|
214
|
+
const child = spawn(CAFFEINATE, ['-d'], { stdio: 'ignore' })
|
|
215
|
+
child.on('error', (error) => {
|
|
216
|
+
console.warn(`${LOG} caffeinate 子进程出错:${error.message}`)
|
|
217
|
+
})
|
|
218
|
+
return child
|
|
219
|
+
}
|
|
220
|
+
|
|
221
|
+
// MARK: - 生命周期
|
|
222
|
+
|
|
223
|
+
function reuseEnabled() {
|
|
224
|
+
const v = String(process.env.CLAMAWAKE_REUSE ?? '1').trim().toLowerCase()
|
|
225
|
+
return v !== '0' && v !== 'false' && v !== 'no'
|
|
226
|
+
}
|
|
227
|
+
|
|
228
|
+
/** 插件启动:解析引擎 → 核对 caffeinate → 只读 list → 复用或建屏。同步完成 spawn,异步尾段只做确认与日志。 */
|
|
229
|
+
function startKeepalive() {
|
|
230
|
+
const { engine, tried } = resolveEngine()
|
|
231
|
+
const engineInfo = describeEngine(engine)
|
|
232
|
+
console.log(`${LOG} 引擎 ${engineInfo.label}:${engine}`)
|
|
233
|
+
checkEngineFingerprint(engine, engineInfo)
|
|
234
|
+
if (!fs.existsSync(CAFFEINATE)) {
|
|
235
|
+
throw new Error(`${LOG} ${CAFFEINATE} 不存在(配方另一半无法执行)。先跑 vd-engine doctor 核对环境。`)
|
|
236
|
+
}
|
|
237
|
+
|
|
238
|
+
const existing = listScreens(engine)
|
|
239
|
+
const kyaScreens = existing.filter((s) => s.kya)
|
|
240
|
+
|
|
241
|
+
const state = {
|
|
242
|
+
version: VERSION,
|
|
243
|
+
engine,
|
|
244
|
+
engine_candidates_tried: tried,
|
|
245
|
+
engine_child: null, // 本插件 spawn 的建屏子进程(复用模式下为 null——所有权边界)
|
|
246
|
+
engine_pid: null,
|
|
247
|
+
caffeinate_child: null,
|
|
248
|
+
caffeinate_pid: null,
|
|
249
|
+
mode: null, // 'created' | 'reused'
|
|
250
|
+
screen_ids: [], // 本插件关心的屏:created=自建屏 id;reused=复用的外部屏 id
|
|
251
|
+
started_at: new Date().toISOString(),
|
|
252
|
+
stopped: false,
|
|
253
|
+
restart_attempt: 0, // 自动重启轮次(成功建屏归零)
|
|
254
|
+
restart_timer: null, // 待执行的退避重启定时器
|
|
255
|
+
}
|
|
256
|
+
|
|
257
|
+
if (kyaScreens.length > 0 && reuseEnabled()) {
|
|
258
|
+
state.mode = 'reused'
|
|
259
|
+
state.screen_ids = kyaScreens.map((s) => s.id)
|
|
260
|
+
console.log(`${LOG} 复用已有 kya=yes 屏 id=${state.screen_ids.join(', ')},不重建;`
|
|
261
|
+
+ `它们的持有进程不属于本插件,本插件停止时不会动它们`)
|
|
262
|
+
spawnCaffeinateFor(state)
|
|
263
|
+
return state
|
|
264
|
+
}
|
|
265
|
+
|
|
266
|
+
state.mode = 'created'
|
|
267
|
+
const { child, screenIdPromise } = spawnEngineCreate(engine)
|
|
268
|
+
state.engine_child = child
|
|
269
|
+
state.engine_pid = child.pid
|
|
270
|
+
spawnCaffeinateFor(state)
|
|
271
|
+
console.log(`${LOG} 已 spawn 引擎建屏子进程 pid=${child.pid}`
|
|
272
|
+
+ `(vd-engine create ${SCREEN_W} ${SCREEN_H} --hidpi --hold --mirror-main,engine=${engine})`)
|
|
273
|
+
watchEngine(state, child, screenIdPromise, 0)
|
|
274
|
+
|
|
275
|
+
return state
|
|
276
|
+
}
|
|
277
|
+
|
|
278
|
+
/**
|
|
279
|
+
* 挂接一个引擎建屏子进程:确认屏 id + 交叉核验(执行后验证——不信子进程一面之词,自己 list),
|
|
280
|
+
* 并把「意外退出」接到退避重启上(attempt=0 首次,≥1 重启轮次)。
|
|
281
|
+
*/
|
|
282
|
+
function watchEngine(state, child, screenIdPromise, attempt) {
|
|
283
|
+
screenIdPromise.then(({ screenId }) => {
|
|
284
|
+
if (state.stopped) return
|
|
285
|
+
state.screen_ids = [screenId]
|
|
286
|
+
state.restart_attempt = 0
|
|
287
|
+
console.log(`${LOG} 引擎建屏成功 id=${screenId}(pid=${child.pid})`
|
|
288
|
+
+ `${attempt > 0 ? `,第 ${attempt} 次重启后恢复` : ''},交叉核验在线状态…`)
|
|
289
|
+
let confirm
|
|
290
|
+
try {
|
|
291
|
+
confirm = listScreens(state.engine)
|
|
292
|
+
} catch (error) {
|
|
293
|
+
console.warn(`${LOG} 建屏后核验失败(list 本身出错):${error.message}`)
|
|
294
|
+
return
|
|
295
|
+
}
|
|
296
|
+
const mine = confirm.find((s) => s.id === screenId)
|
|
297
|
+
if (mine && mine.kya) {
|
|
298
|
+
console.log(`${LOG} 核验通过:id=${screenId} 在线且 kya=yes,保活配方就位`
|
|
299
|
+
+ `(虚拟屏 + caffeinate pid=${state.caffeinate_pid})`)
|
|
300
|
+
} else {
|
|
301
|
+
console.warn(`${LOG} 核验未通过:id=${screenId} 不在在线列表或 kya!=yes(读数:${JSON.stringify(mine)})`)
|
|
302
|
+
}
|
|
303
|
+
}, (error) => {
|
|
304
|
+
if (state.stopped) return
|
|
305
|
+
console.warn(`${LOG} 建屏失败:${error.message}`)
|
|
306
|
+
restartEngine(state, attempt + 1)
|
|
307
|
+
})
|
|
308
|
+
|
|
309
|
+
child.on('exit', (code, signal) => {
|
|
310
|
+
if (state.stopped) return
|
|
311
|
+
console.warn(`${LOG} 引擎子进程意外退出(pid=${child.pid} code=${code} signal=${signal})——`
|
|
312
|
+
+ `自建虚拟屏随之消失,保活失效;进入自动重启`)
|
|
313
|
+
restartEngine(state, attempt + 1)
|
|
314
|
+
})
|
|
315
|
+
}
|
|
316
|
+
|
|
317
|
+
/**
|
|
318
|
+
* 退避重启引擎建屏子进程:1s 起、每次翻倍、30s 封顶;插件停止(state.stopped)即不再重启。
|
|
319
|
+
* caffeinate 断言独立于屏,重启期间保留不重建。
|
|
320
|
+
*/
|
|
321
|
+
function restartEngine(state, attempt) {
|
|
322
|
+
if (state.stopped) return
|
|
323
|
+
if (state.restart_timer) return // 已有排程(exit 与建屏失败可能同时触发)
|
|
324
|
+
state.restart_attempt = attempt
|
|
325
|
+
const delay = Math.min(RESTART_BASE_MS * 2 ** Math.min(attempt - 1, 5), RESTART_MAX_MS)
|
|
326
|
+
console.warn(`${LOG} 第 ${attempt} 次自动重启引擎(${delay}ms 后)`)
|
|
327
|
+
const timer = setTimeout(() => {
|
|
328
|
+
state.restart_timer = null
|
|
329
|
+
if (state.stopped) return
|
|
330
|
+
const { child, screenIdPromise } = spawnEngineCreate(state.engine)
|
|
331
|
+
state.engine_child = child
|
|
332
|
+
state.engine_pid = child.pid
|
|
333
|
+
console.log(`${LOG} 重启引擎建屏子进程 pid=${child.pid}(第 ${attempt} 次)`)
|
|
334
|
+
watchEngine(state, child, screenIdPromise, attempt)
|
|
335
|
+
}, delay)
|
|
336
|
+
if (timer.unref) timer.unref()
|
|
337
|
+
state.restart_timer = timer
|
|
338
|
+
}
|
|
339
|
+
|
|
340
|
+
function spawnCaffeinateFor(state) {
|
|
341
|
+
const child = spawnCaffeinate()
|
|
342
|
+
state.caffeinate_child = child
|
|
343
|
+
state.caffeinate_pid = child.pid
|
|
344
|
+
console.log(`${LOG} caffeinate -d 断言已挂(pid=${child.pid})`)
|
|
345
|
+
}
|
|
346
|
+
|
|
347
|
+
/** 插件停止:只 SIGTERM 自己 spawn 的子进程(复用的外部屏绝不动),SIGKILL 只作兜底升级。同步触发、不阻塞 dispose。 */
|
|
348
|
+
function stopKeepalive(state) {
|
|
349
|
+
if (!state || state.stopped) return
|
|
350
|
+
state.stopped = true
|
|
351
|
+
if (state.restart_timer) {
|
|
352
|
+
clearTimeout(state.restart_timer)
|
|
353
|
+
state.restart_timer = null
|
|
354
|
+
}
|
|
355
|
+
let killedAny = false
|
|
356
|
+
for (const child of [state.engine_child, state.caffeinate_child]) {
|
|
357
|
+
if (!child || child.exitCode !== null || child.signalCode !== null) continue
|
|
358
|
+
try { child.kill('SIGTERM') } catch {}
|
|
359
|
+
killedAny = true
|
|
360
|
+
const escalate = setTimeout(() => {
|
|
361
|
+
if (child.exitCode === null && child.signalCode === null) {
|
|
362
|
+
console.warn(`${LOG} 子进程 pid=${child.pid} SIGTERM 后 ${KILL_GRACE_MS}ms 未退出,升级 SIGKILL`)
|
|
363
|
+
try { child.kill('SIGKILL') } catch {}
|
|
364
|
+
}
|
|
365
|
+
}, KILL_GRACE_MS)
|
|
366
|
+
if (escalate.unref) escalate.unref()
|
|
367
|
+
}
|
|
368
|
+
if (state.mode === 'reused') {
|
|
369
|
+
console.log(`${LOG} 已停止:释放本插件的 caffeinate 断言;复用的屏 id=${state.screen_ids.join(', ')}`
|
|
370
|
+
+ `保持原样(持有者不是本插件)`)
|
|
371
|
+
} else {
|
|
372
|
+
console.log(`${LOG} 已停止:SIGTERM 引擎子进程${killedAny ? '(pid=' + state.engine_pid + ')' : ''}`
|
|
373
|
+
+ `与 caffeinate(pid=${state.caffeinate_pid}),自建虚拟屏随引擎退出消失`)
|
|
374
|
+
}
|
|
375
|
+
}
|
|
376
|
+
|
|
377
|
+
// 最近一次 start 的 state。apply 的返回值会被 cordis 当 effect 消费(返回普通对象 →
|
|
378
|
+
// TypeError: Invalid effect),所以状态不经 apply 返回,改用 getState() 暴露。
|
|
379
|
+
let latestState = null
|
|
380
|
+
|
|
381
|
+
export function getState() {
|
|
382
|
+
return latestState
|
|
383
|
+
}
|
|
384
|
+
|
|
385
|
+
export default {
|
|
386
|
+
name: 'dsh-clamawake',
|
|
387
|
+
apply(ctx) {
|
|
388
|
+
let state = null
|
|
389
|
+
ctx.effect(() => {
|
|
390
|
+
state = startKeepalive()
|
|
391
|
+
latestState = state
|
|
392
|
+
return () => stopKeepalive(state)
|
|
393
|
+
}, 'clamawake: keepalive engine (vd-engine --hold + caffeinate -d)')
|
|
394
|
+
},
|
|
395
|
+
}
|
package/locale/en.json
ADDED
|
@@ -0,0 +1,6 @@
|
|
|
1
|
+
{
|
|
2
|
+
"meta": {
|
|
3
|
+
"title": "ClamAwake Keepalive",
|
|
4
|
+
"description": "Binds the ClamAwake clamshell keepalive recipe to the DSH host lifecycle: on host start it brings up the virtual-display recipe (vd-engine --hold + caffeinate -d); on host stop it terminates only its own child processes. Reuses an existing kya=yes keepalive display instead of creating a duplicate."
|
|
5
|
+
}
|
|
6
|
+
}
|
package/locale/zh.json
ADDED
package/package.json
CHANGED
|
@@ -1,6 +1,55 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "dsh-clamawake",
|
|
3
|
-
"version": "0.
|
|
4
|
-
"
|
|
5
|
-
"description": "
|
|
6
|
-
|
|
3
|
+
"version": "0.1.1",
|
|
4
|
+
"private": false,
|
|
5
|
+
"description": "ClamAwake keep-alive for DeepSeek Harness (macOS): binds the lid-closed keep-alive recipe (virtual display + caffeinate -d) to the host lifecycle. Self-contained — ships the engine, no separate app required. Reuses an existing keepalive display; restarts a crashed engine with backoff.",
|
|
6
|
+
"type": "module",
|
|
7
|
+
"main": "index.js",
|
|
8
|
+
"exports": {
|
|
9
|
+
".": "./index.js",
|
|
10
|
+
"./package.json": "./package.json",
|
|
11
|
+
"./locale/*.json": "./locale/*.json"
|
|
12
|
+
},
|
|
13
|
+
"files": [
|
|
14
|
+
"index.js",
|
|
15
|
+
"cordis.patch.yml",
|
|
16
|
+
"locale/*.json",
|
|
17
|
+
"README.md",
|
|
18
|
+
"LICENSE",
|
|
19
|
+
"NOTICE",
|
|
20
|
+
"bin/"
|
|
21
|
+
],
|
|
22
|
+
"dsh": {
|
|
23
|
+
"bundle": {
|
|
24
|
+
"patch": "./cordis.patch.yml"
|
|
25
|
+
}
|
|
26
|
+
},
|
|
27
|
+
"license": "MIT",
|
|
28
|
+
"repository": {
|
|
29
|
+
"type": "git",
|
|
30
|
+
"url": "git+https://github.com/zhangweijian97/dsh-clamawake.git"
|
|
31
|
+
},
|
|
32
|
+
"homepage": "https://github.com/zhangweijian97/dsh-clamawake",
|
|
33
|
+
"bugs": {
|
|
34
|
+
"url": "https://github.com/zhangweijian97/dsh-clamawake/issues"
|
|
35
|
+
},
|
|
36
|
+
"author": {
|
|
37
|
+
"name": "zhangweijian97",
|
|
38
|
+
"url": "https://github.com/zhangweijian97"
|
|
39
|
+
},
|
|
40
|
+
"keywords": [
|
|
41
|
+
"dsh-plugin",
|
|
42
|
+
"dsh-bundle",
|
|
43
|
+
"macos",
|
|
44
|
+
"clamshell",
|
|
45
|
+
"keepalive",
|
|
46
|
+
"clamawake",
|
|
47
|
+
"virtual-display"
|
|
48
|
+
],
|
|
49
|
+
"engines": {
|
|
50
|
+
"dsh": ">=0.2.0"
|
|
51
|
+
},
|
|
52
|
+
"os": [
|
|
53
|
+
"darwin"
|
|
54
|
+
]
|
|
55
|
+
}
|