@alequet/dsh-patchkeeper 0.0.0-stage → 0.5.3
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/README.md +67 -2
- package/bin/cli.mjs +749 -0
- package/client.js +472 -0
- package/cordis.patch.yml +6 -0
- package/index.js +176 -0
- package/package.json +41 -4
package/bin/cli.mjs
ADDED
|
@@ -0,0 +1,749 @@
|
|
|
1
|
+
#!/usr/bin/env node
|
|
2
|
+
/**
|
|
3
|
+
* dsh-patchkeeper CLI — 影子副本(shadow mount)架构。
|
|
4
|
+
*
|
|
5
|
+
* 核心思想:永不修改原版插件。
|
|
6
|
+
* apply = 复制原版 → 补丁打进副本 → node_modules 条目换名挂载到副本
|
|
7
|
+
* revert = 摘挂载、销毁副本、原版归位(崩溃没执行也不要紧)
|
|
8
|
+
* 启动时 = 先按 state.json 保底清除上次残留,再做版本匹配挂载
|
|
9
|
+
*
|
|
10
|
+
* 用法:
|
|
11
|
+
* node cli.mjs extract [--pkg <name>] 从 npm 原版 diff 出补丁,写入 patches/
|
|
12
|
+
* node cli.mjs apply [--force] [--pkg] 版本匹配则挂载补丁副本
|
|
13
|
+
* node cli.mjs revert [--pkg] 摘挂载、销毁副本、恢复原版
|
|
14
|
+
* node cli.mjs status 只看状态不改文件
|
|
15
|
+
* node cli.mjs list 列出补丁清单
|
|
16
|
+
* node cli.mjs doctor [--fix] 检查/修复插件在 profile 里的注册
|
|
17
|
+
*
|
|
18
|
+
* 通用: --json 输出 JSON;DSH_PROFILE 覆盖 profile 路径。
|
|
19
|
+
*/
|
|
20
|
+
import { spawnSync } from 'node:child_process'
|
|
21
|
+
import fs from 'node:fs'
|
|
22
|
+
import os from 'node:os'
|
|
23
|
+
import path from 'node:path'
|
|
24
|
+
import { fileURLToPath } from 'node:url'
|
|
25
|
+
|
|
26
|
+
// 代码与数据分离:包可以被升级/重装/公开分发,补丁数据独立于包存在
|
|
27
|
+
const TOOL_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..')
|
|
28
|
+
const DATA_DIR = process.env.DSH_PATCHKEEPER_HOME || path.join(os.homedir(), '.dsh', 'patch-manager')
|
|
29
|
+
const PATCHES_DIR = path.join(DATA_DIR, 'patches')
|
|
30
|
+
const BIN_DIR = path.join(PATCHES_DIR, 'bin') // 二进制改动整文件存放
|
|
31
|
+
const REJECTS_DIR = path.join(DATA_DIR, 'rejects')
|
|
32
|
+
const STATE_FILE = path.join(DATA_DIR, 'state.json')
|
|
33
|
+
|
|
34
|
+
function resolveProfile() {
|
|
35
|
+
const env = process.env.DSH_PROFILE
|
|
36
|
+
if (!env) return path.join(os.homedir(), '.dsh', 'profiles', 'desktop')
|
|
37
|
+
if (path.isAbsolute(env)) return env
|
|
38
|
+
return path.join(os.homedir(), '.dsh', 'profiles', env)
|
|
39
|
+
}
|
|
40
|
+
const PROFILE = resolveProfile()
|
|
41
|
+
const NM = path.join(PROFILE, 'node_modules')
|
|
42
|
+
// 影子副本必须放在 profile 的 node_modules 树内:依赖解析沿目录向上走,能摸到平铺的兄弟依赖
|
|
43
|
+
// ≤0.2.0 曾放在 node_modules/.patchkeeper-shadows,被 pnpm reconcile 当游离目录剪掉过(实测)
|
|
44
|
+
const LEGACY_SHADOWS = path.join(NM, '.patchkeeper-shadows')
|
|
45
|
+
// 副本放数据目录,pnpm 管不着;副本内补 node_modules 软链指回 profile 解决依赖解析
|
|
46
|
+
const SHADOWS = path.join(DATA_DIR, 'shadows')
|
|
47
|
+
const shadowDir = (slug) => path.join(SHADOWS, slug)
|
|
48
|
+
const origDir = (slug) => path.join(SHADOWS, 'orig', slug)
|
|
49
|
+
|
|
50
|
+
// 挂载时写进副本 package.json 的生效标记(extract 前会摘掉,不污染补丁)
|
|
51
|
+
const MOUNT_MARKER = '🩹 补丁生效中(patchkeeper)'
|
|
52
|
+
|
|
53
|
+
// diff 时排除的东西:运行时缓存、日志、本地备份等
|
|
54
|
+
const EXCLUDES = [
|
|
55
|
+
'node_modules', '.git', '.svn', '.DS_Store', 'Thumbs.db',
|
|
56
|
+
'*.log', 'logs', 'tmp', '.cache', 'Cache', '__pycache__',
|
|
57
|
+
'.pnpm-store', '*.tsbuildinfo', '*.rej', '*.orig', '*.bak', '*.bak-*', 'pnpm-lock.yaml',
|
|
58
|
+
]
|
|
59
|
+
|
|
60
|
+
// 不进补丁管理的包(我们自己 / 本地包)
|
|
61
|
+
const SKIP_PKGS = new Set(['@alequet/dsh-patchkeeper', 'dsh-patchkeeper'])
|
|
62
|
+
|
|
63
|
+
// ---------- 小工具 ----------
|
|
64
|
+
|
|
65
|
+
const slugOf = (name) => name.replace('/', '+') // @scope/name -> @scope+name
|
|
66
|
+
const nameOf = (slug) => (slug.startsWith('@') ? slug.replace('+', '/') : slug)
|
|
67
|
+
|
|
68
|
+
function parsePatchFile(file) {
|
|
69
|
+
const m = /^(?<slug>.+)__(?<version>.+)\.patch$/.exec(file)
|
|
70
|
+
if (!m) return null
|
|
71
|
+
return { file, slug: m.groups.slug, name: nameOf(m.groups.slug), version: m.groups.version }
|
|
72
|
+
}
|
|
73
|
+
|
|
74
|
+
function listPatchFiles() {
|
|
75
|
+
if (!fs.existsSync(PATCHES_DIR)) return []
|
|
76
|
+
return fs.readdirSync(PATCHES_DIR).map(parsePatchFile).filter(Boolean)
|
|
77
|
+
}
|
|
78
|
+
|
|
79
|
+
function readJson(p) {
|
|
80
|
+
return JSON.parse(fs.readFileSync(p, 'utf8'))
|
|
81
|
+
}
|
|
82
|
+
|
|
83
|
+
function readState() {
|
|
84
|
+
try {
|
|
85
|
+
return readJson(STATE_FILE)
|
|
86
|
+
} catch {
|
|
87
|
+
return {}
|
|
88
|
+
}
|
|
89
|
+
}
|
|
90
|
+
|
|
91
|
+
function writeState(patch) {
|
|
92
|
+
const state = { ...readState(), ...patch }
|
|
93
|
+
fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2))
|
|
94
|
+
}
|
|
95
|
+
|
|
96
|
+
// 已装版本一律读 node_modules 条目本身:挂载时软链指向副本(版本与原版一致),
|
|
97
|
+
// 未挂载时就是真实安装;orig 备份可能是过时的,不看它。
|
|
98
|
+
function installedVersion(name) {
|
|
99
|
+
try {
|
|
100
|
+
return readJson(path.join(NM, name, 'package.json')).version || null
|
|
101
|
+
} catch {
|
|
102
|
+
return null
|
|
103
|
+
}
|
|
104
|
+
}
|
|
105
|
+
|
|
106
|
+
// 当前是否挂载着影子副本(node_modules 条目是指向我们副本的软链)
|
|
107
|
+
function isMounted(name, slug) {
|
|
108
|
+
const entry = path.join(NM, name)
|
|
109
|
+
try {
|
|
110
|
+
const lst = fs.lstatSync(entry)
|
|
111
|
+
if (!lst.isSymbolicLink()) return false
|
|
112
|
+
return fs.realpathSync(entry) === fs.realpathSync(shadowDir(slug))
|
|
113
|
+
} catch {
|
|
114
|
+
return false
|
|
115
|
+
}
|
|
116
|
+
}
|
|
117
|
+
|
|
118
|
+
function run(cmd, args, opts = {}) {
|
|
119
|
+
return spawnSync(cmd, args, { encoding: 'utf8', maxBuffer: 512 * 1024 * 1024, ...opts })
|
|
120
|
+
}
|
|
121
|
+
|
|
122
|
+
// patch 检测:返回 'not-applied' | 'applied' | 'conflict'
|
|
123
|
+
function probePatch(dir, patchFile) {
|
|
124
|
+
const base = ['--dry-run', '-p1', '-N', '-E', '-d', dir, '-i', patchFile]
|
|
125
|
+
const fwd = run('patch', base)
|
|
126
|
+
if (fwd.status === 0) return 'not-applied'
|
|
127
|
+
const rev = run('patch', [...base, '-R'])
|
|
128
|
+
if (rev.status === 0) return 'applied'
|
|
129
|
+
return 'conflict'
|
|
130
|
+
}
|
|
131
|
+
|
|
132
|
+
function binFilesOf(slug) {
|
|
133
|
+
const binBase = path.join(BIN_DIR, slug)
|
|
134
|
+
if (!fs.existsSync(binBase)) return { binBase, files: [] }
|
|
135
|
+
return {
|
|
136
|
+
binBase,
|
|
137
|
+
files: fs.readdirSync(binBase, { recursive: true }).filter((f) => fs.statSync(path.join(binBase, f)).isFile()),
|
|
138
|
+
}
|
|
139
|
+
}
|
|
140
|
+
|
|
141
|
+
// ---------- 保底清除(每次启动 apply 前必跑) ----------
|
|
142
|
+
|
|
143
|
+
// 把挂载状态恢复成原版归位、副本销毁。崩溃残留、孤儿副本都在这里清。
|
|
144
|
+
function ensureCleanMount({ only } = {}) {
|
|
145
|
+
const repaired = []
|
|
146
|
+
cleanLegacyMounts()
|
|
147
|
+
const state = readState()
|
|
148
|
+
const swaps = state.swaps || {}
|
|
149
|
+
for (const [name] of Object.entries(swaps)) {
|
|
150
|
+
if (only && name !== only) continue
|
|
151
|
+
const p = { name, slug: slugOf(name) }
|
|
152
|
+
// 健康挂载(软链在、副本在、备份在)原地不动:启动时拆装了重挂,会跟冻结快照抢同一扇窗
|
|
153
|
+
if (isMounted(p.name, p.slug) && fs.existsSync(origDir(p.slug))) continue
|
|
154
|
+
if (dismount(p)) repaired.push(name)
|
|
155
|
+
}
|
|
156
|
+
// 孤儿副本清扫:state 里没登记但 shadows 里躺着的(比如 state.json 丢了)
|
|
157
|
+
if (fs.existsSync(SHADOWS)) {
|
|
158
|
+
for (const dirent of fs.readdirSync(SHADOWS, { withFileTypes: true })) {
|
|
159
|
+
if (dirent.name === 'orig') continue
|
|
160
|
+
const name = nameOf(dirent.name)
|
|
161
|
+
if (swaps[name]) continue
|
|
162
|
+
// 没登记的副本:如果 orig/ 里有对应原版且 node_modules 条目还指过来,也一并恢复
|
|
163
|
+
const p = { name, slug: dirent.name }
|
|
164
|
+
if (isMounted(name, dirent.name)) dismount(p)
|
|
165
|
+
else fs.rmSync(shadowDir(dirent.name), { recursive: true, force: true })
|
|
166
|
+
}
|
|
167
|
+
}
|
|
168
|
+
return repaired
|
|
169
|
+
}
|
|
170
|
+
|
|
171
|
+
// 旧版(≤0.2.0)挂载遗址清理:条目是指向 node_modules/.patchkeeper-shadows 的软链,
|
|
172
|
+
// 原版备份在其 orig/ 下。恢复原位后整个旧目录删除。
|
|
173
|
+
function cleanLegacyMounts() {
|
|
174
|
+
if (!fs.existsSync(LEGACY_SHADOWS)) return
|
|
175
|
+
for (const dirent of fs.readdirSync(LEGACY_SHADOWS, { withFileTypes: true })) {
|
|
176
|
+
if (dirent.name === 'orig') continue
|
|
177
|
+
const slug = dirent.name
|
|
178
|
+
const name = nameOf(slug)
|
|
179
|
+
const entry = path.join(NM, name)
|
|
180
|
+
try {
|
|
181
|
+
if (fs.lstatSync(entry).isSymbolicLink() && fs.realpathSync(entry) === fs.realpathSync(path.join(LEGACY_SHADOWS, slug))) {
|
|
182
|
+
fs.rmSync(entry, { force: true })
|
|
183
|
+
}
|
|
184
|
+
} catch {}
|
|
185
|
+
const legacyOrig = path.join(LEGACY_SHADOWS, 'orig', slug)
|
|
186
|
+
if (fs.existsSync(legacyOrig) && !fs.existsSync(entry) && profileLists(name)) {
|
|
187
|
+
fs.mkdirSync(path.dirname(entry), { recursive: true })
|
|
188
|
+
fs.renameSync(legacyOrig, entry)
|
|
189
|
+
}
|
|
190
|
+
}
|
|
191
|
+
fs.rmSync(LEGACY_SHADOWS, { recursive: true, force: true })
|
|
192
|
+
}
|
|
193
|
+
|
|
194
|
+
// 插件是否仍在 profile 依赖清单里(不在 = 用户已卸载,原版备份不能复活它)
|
|
195
|
+
function profileLists(name) {
|
|
196
|
+
try {
|
|
197
|
+
const pkg = readJson(path.join(PROFILE, 'package.json'))
|
|
198
|
+
return Object.hasOwn(pkg.dependencies ?? {}, name)
|
|
199
|
+
} catch {
|
|
200
|
+
return true // 读不到清单时保守处理:恢复原版
|
|
201
|
+
}
|
|
202
|
+
}
|
|
203
|
+
|
|
204
|
+
// ---------- 补丁配置(启用开关 + 效果说明,随 patches/ 入 git) ----------
|
|
205
|
+
|
|
206
|
+
const CONFIG_FILE = path.join(PATCHES_DIR, 'config.json')
|
|
207
|
+
|
|
208
|
+
function readConfig() {
|
|
209
|
+
try {
|
|
210
|
+
return readJson(CONFIG_FILE)
|
|
211
|
+
} catch {
|
|
212
|
+
return {}
|
|
213
|
+
}
|
|
214
|
+
}
|
|
215
|
+
|
|
216
|
+
function writeConfig(cfg) {
|
|
217
|
+
fs.mkdirSync(PATCHES_DIR, { recursive: true })
|
|
218
|
+
fs.writeFileSync(CONFIG_FILE, JSON.stringify(cfg, null, 2) + '\n')
|
|
219
|
+
}
|
|
220
|
+
|
|
221
|
+
const isEnabled = (name) => readConfig()[name]?.enabled !== false
|
|
222
|
+
|
|
223
|
+
// 从补丁文件解析被覆盖的文件清单(供 UI 展示)
|
|
224
|
+
function patchFileList(p) {
|
|
225
|
+
const files = []
|
|
226
|
+
const patchPath = path.join(PATCHES_DIR, p.file)
|
|
227
|
+
if (fs.existsSync(patchPath)) {
|
|
228
|
+
const text = fs.readFileSync(patchPath, 'utf8')
|
|
229
|
+
for (const m of text.matchAll(/^diff -ruN a\/(?<f>.+?) b\/.+$/gm)) files.push(m.groups.f)
|
|
230
|
+
}
|
|
231
|
+
files.push(...binFilesOf(p.slug).files.map((f) => f + ' (binary)'))
|
|
232
|
+
return files
|
|
233
|
+
}
|
|
234
|
+
|
|
235
|
+
// 摘一个挂载:删我们的软链 → 原版归位 → 销毁副本。返回是否有实际清理动作。
|
|
236
|
+
// 竞态防护:若条目已被外部(升级器)换成新安装,原版备份已过时——丢弃备份,保留新装。
|
|
237
|
+
function dismount(p) {
|
|
238
|
+
const entry = path.join(NM, p.name)
|
|
239
|
+
const shadow = shadowDir(p.slug)
|
|
240
|
+
const orig = origDir(p.slug)
|
|
241
|
+
const hadWork = isMounted(p.name, p.slug) || fs.existsSync(orig) || fs.existsSync(shadow)
|
|
242
|
+
if (isMounted(p.name, p.slug)) fs.rmSync(entry, { force: true })
|
|
243
|
+
if (fs.existsSync(orig)) {
|
|
244
|
+
if (!fs.existsSync(entry) && profileLists(p.name)) {
|
|
245
|
+
fs.mkdirSync(path.dirname(entry), { recursive: true })
|
|
246
|
+
fs.renameSync(orig, entry) // 同分区 rename,原子
|
|
247
|
+
} else {
|
|
248
|
+
// 条目已被在线更新替换成新版,或插件已被卸载:备份已过时,丢弃不复活
|
|
249
|
+
fs.rmSync(orig, { recursive: true, force: true })
|
|
250
|
+
}
|
|
251
|
+
}
|
|
252
|
+
fs.rmSync(shadow, { recursive: true, force: true })
|
|
253
|
+
// 顺手清掉空壳目录(orig/ 与 shadows 本身,空了才删得掉)
|
|
254
|
+
try { fs.rmdirSync(path.join(SHADOWS, 'orig')) } catch {}
|
|
255
|
+
try { fs.rmdirSync(SHADOWS) } catch {}
|
|
256
|
+
const state = readState()
|
|
257
|
+
if (state.swaps && state.swaps[p.name]) {
|
|
258
|
+
delete state.swaps[p.name]
|
|
259
|
+
writeState({ swaps: state.swaps })
|
|
260
|
+
}
|
|
261
|
+
return hadWork
|
|
262
|
+
}
|
|
263
|
+
|
|
264
|
+
// ---------- extract ----------
|
|
265
|
+
|
|
266
|
+
function extractOne(name, spec, { log }) {
|
|
267
|
+
const result = { name, ok: false }
|
|
268
|
+
const slug = slugOf(name)
|
|
269
|
+
const mounted = isMounted(name, slug)
|
|
270
|
+
// 挂载中:entry 软链指向副本——从副本提补丁,这正是「在副本上实验 → 入库」的调试循环
|
|
271
|
+
const dir = path.join(NM, name)
|
|
272
|
+
if (!fs.existsSync(dir)) {
|
|
273
|
+
result.error = 'not-installed'
|
|
274
|
+
return result
|
|
275
|
+
}
|
|
276
|
+
if (/^file:|^link:/.test(spec)) {
|
|
277
|
+
result.error = 'local-package-skipped'
|
|
278
|
+
return result
|
|
279
|
+
}
|
|
280
|
+
const version = installedVersion(name)
|
|
281
|
+
result.version = version
|
|
282
|
+
|
|
283
|
+
const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'patchkeeper-'))
|
|
284
|
+
let markedDesc = null // 生效标记的原文(finally 里恢复)
|
|
285
|
+
const entryPkg = path.join(dir, 'package.json') // 提升作用域:finally 要用
|
|
286
|
+
try {
|
|
287
|
+
const packSpec = /^https?:/.test(spec) ? spec : `${name}@${version}`
|
|
288
|
+
const pack = run('npm', ['pack', packSpec, '--pack-destination', tmp, '--silent'], { cwd: tmp })
|
|
289
|
+
if (pack.status !== 0) {
|
|
290
|
+
result.error = `npm pack failed: ${(pack.stderr || '').slice(0, 300)}`
|
|
291
|
+
return result
|
|
292
|
+
}
|
|
293
|
+
const tarball = (pack.stdout || '').trim().split('\n').pop().trim()
|
|
294
|
+
const aDir = path.join(tmp, 'a')
|
|
295
|
+
fs.mkdirSync(aDir)
|
|
296
|
+
const untar = run('tar', ['-xzf', path.join(tmp, tarball), '-C', aDir, '--strip-components=1'])
|
|
297
|
+
if (untar.status !== 0) {
|
|
298
|
+
result.error = `tar failed: ${(untar.stderr || '').slice(0, 300)}`
|
|
299
|
+
return result
|
|
300
|
+
}
|
|
301
|
+
// 副本 package.json 上的生效标记不属于用户改动:临时摘掉,diff 完恢复
|
|
302
|
+
try {
|
|
303
|
+
const epkg = readJson(entryPkg)
|
|
304
|
+
if (String(epkg.description || '').includes(MOUNT_MARKER)) {
|
|
305
|
+
markedDesc = epkg.description
|
|
306
|
+
epkg.description = markedDesc.replace(MOUNT_MARKER, '').trim()
|
|
307
|
+
fs.writeFileSync(entryPkg, JSON.stringify(epkg, null, 2) + '\n')
|
|
308
|
+
}
|
|
309
|
+
} catch {}
|
|
310
|
+
fs.symlinkSync(dir, path.join(tmp, 'b'))
|
|
311
|
+
const exclFile = path.join(tmp, 'excludes.txt')
|
|
312
|
+
fs.writeFileSync(exclFile, EXCLUDES.join('\n') + '\n')
|
|
313
|
+
|
|
314
|
+
const diff = run('diff', ['-ruN', '-X', exclFile, 'a', 'b'], { cwd: tmp })
|
|
315
|
+
if (diff.status === 0) {
|
|
316
|
+
result.ok = true
|
|
317
|
+
result.changed = []
|
|
318
|
+
return result // 与原版一致,无补丁
|
|
319
|
+
}
|
|
320
|
+
if (diff.status !== 1) {
|
|
321
|
+
result.error = `diff error: ${(diff.stderr || '').slice(0, 300)}`
|
|
322
|
+
return result
|
|
323
|
+
}
|
|
324
|
+
|
|
325
|
+
// 摘出二进制差异:整文件另存,不进文本补丁
|
|
326
|
+
const binFiles = []
|
|
327
|
+
const keptLines = []
|
|
328
|
+
for (const line of diff.stdout.match(/.*(\n|$)/g).filter((l) => l.length)) {
|
|
329
|
+
const bm = /^Binary files a\/(?<p>.+) and b\/.+ differ$/.exec(line)
|
|
330
|
+
if (bm) {
|
|
331
|
+
binFiles.push(bm.groups.p)
|
|
332
|
+
continue
|
|
333
|
+
}
|
|
334
|
+
keptLines.push(line)
|
|
335
|
+
}
|
|
336
|
+
if (binFiles.length) {
|
|
337
|
+
const destBase = path.join(BIN_DIR, slug)
|
|
338
|
+
fs.mkdirSync(destBase, { recursive: true })
|
|
339
|
+
for (const rel of binFiles) {
|
|
340
|
+
const dest = path.join(destBase, rel)
|
|
341
|
+
fs.mkdirSync(path.dirname(dest), { recursive: true })
|
|
342
|
+
fs.copyFileSync(path.join(dir, rel), dest)
|
|
343
|
+
}
|
|
344
|
+
} else {
|
|
345
|
+
fs.rmSync(path.join(BIN_DIR, slug), { recursive: true, force: true })
|
|
346
|
+
}
|
|
347
|
+
|
|
348
|
+
// diff 头部会带上 -X 参数与临时路径,统一规范化成 `diff -ruN a/x b/x`
|
|
349
|
+
const body = keptLines.join('').replace(/^diff -ruN.*? (?=a\/)/gm, 'diff -ruN ')
|
|
350
|
+
const changed = [...body.matchAll(/^diff -ruN a\/(?<p>.+?) b\/.+$/gm)].map((m) => m.groups.p)
|
|
351
|
+
result.changed = [...changed, ...binFiles.map((p) => p + ' (binary)')]
|
|
352
|
+
|
|
353
|
+
fs.mkdirSync(PATCHES_DIR, { recursive: true })
|
|
354
|
+
const target = path.join(PATCHES_DIR, `${slug}__${version}.patch`)
|
|
355
|
+
if (body.trim()) {
|
|
356
|
+
const header =
|
|
357
|
+
`# dsh-patchkeeper patch\n` +
|
|
358
|
+
`# package: ${name}\n# version: ${version}\n` +
|
|
359
|
+
`# extracted: ${new Date().toISOString()}\n`
|
|
360
|
+
fs.writeFileSync(target, header + body)
|
|
361
|
+
} else {
|
|
362
|
+
fs.rmSync(target, { force: true })
|
|
363
|
+
}
|
|
364
|
+
// 清掉同包旧版本补丁
|
|
365
|
+
for (const p of listPatchFiles()) {
|
|
366
|
+
if (p.slug === slug && p.version !== version) {
|
|
367
|
+
fs.rmSync(path.join(PATCHES_DIR, p.file), { force: true })
|
|
368
|
+
log?.(` 清理旧版本补丁: ${p.file}`)
|
|
369
|
+
}
|
|
370
|
+
}
|
|
371
|
+
// 未挂载时有人直接改了原版:改动已收进补丁,顺手把原版恢复纯净(保住「原版永远干净」)
|
|
372
|
+
if (!mounted && result.changed?.length) {
|
|
373
|
+
let restored = 0
|
|
374
|
+
for (const rawRel of result.changed) {
|
|
375
|
+
const rel = rawRel.replace(/ \(binary\)$/, '')
|
|
376
|
+
const pristine = path.join(aDir, rel)
|
|
377
|
+
const target = path.join(dir, rel)
|
|
378
|
+
if (fs.existsSync(pristine)) fs.copyFileSync(pristine, target)
|
|
379
|
+
else fs.rmSync(target, { force: true }) // pristine 没有 = 新增文件,从原版删掉
|
|
380
|
+
restored++
|
|
381
|
+
}
|
|
382
|
+
if (restored) log?.(` 已把原版恢复纯净(${restored} 个文件的改动已在补丁里)`)
|
|
383
|
+
}
|
|
384
|
+
result.ok = true
|
|
385
|
+
return result
|
|
386
|
+
} finally {
|
|
387
|
+
// 恢复生效标记(finally 兜住所有提前 return 路径)
|
|
388
|
+
if (markedDesc !== null) {
|
|
389
|
+
try {
|
|
390
|
+
const epkg = readJson(entryPkg)
|
|
391
|
+
epkg.description = markedDesc
|
|
392
|
+
fs.writeFileSync(entryPkg, JSON.stringify(epkg, null, 2) + '\n')
|
|
393
|
+
} catch {}
|
|
394
|
+
}
|
|
395
|
+
fs.rmSync(tmp, { recursive: true, force: true })
|
|
396
|
+
}
|
|
397
|
+
}
|
|
398
|
+
|
|
399
|
+
function cmdExtract({ only, log }) {
|
|
400
|
+
const pkgFile = readJson(path.join(PROFILE, 'package.json'))
|
|
401
|
+
const deps = Object.entries(pkgFile.dependencies || {})
|
|
402
|
+
const results = []
|
|
403
|
+
for (const [name, spec] of deps) {
|
|
404
|
+
if (SKIP_PKGS.has(name)) continue
|
|
405
|
+
if (only && name !== only) continue
|
|
406
|
+
log?.(`diff ${name} …`)
|
|
407
|
+
const r = extractOne(name, spec, { log })
|
|
408
|
+
if (r.error) log?.(` ✗ ${r.error}`)
|
|
409
|
+
else if (r.changed?.length) log?.(` ✓ ${r.changed.length} 个文件有改动`)
|
|
410
|
+
else log?.(` - 与原版一致`)
|
|
411
|
+
results.push(r)
|
|
412
|
+
}
|
|
413
|
+
return { command: 'extract', results }
|
|
414
|
+
}
|
|
415
|
+
|
|
416
|
+
// ---------- apply / revert / status(影子副本) ----------
|
|
417
|
+
|
|
418
|
+
// 把补丁打进指定目录(shadow 副本),失败返回 false
|
|
419
|
+
function patchInto(dir, p) {
|
|
420
|
+
const patchPath = path.join(PATCHES_DIR, p.file)
|
|
421
|
+
const hasTextPatch = fs.existsSync(patchPath)
|
|
422
|
+
const { binBase, files: binFiles } = binFilesOf(p.slug)
|
|
423
|
+
if (hasTextPatch) {
|
|
424
|
+
fs.mkdirSync(REJECTS_DIR, { recursive: true })
|
|
425
|
+
const rej = path.join(REJECTS_DIR, `${p.slug}.rej`)
|
|
426
|
+
fs.rmSync(rej, { force: true })
|
|
427
|
+
const ap = run('patch', ['-p1', '-N', '-E', '-f', '-d', dir, '-i', patchPath, '-r', rej])
|
|
428
|
+
if (ap.status !== 0) return false
|
|
429
|
+
if (probePatch(dir, patchPath) !== 'applied') return false
|
|
430
|
+
}
|
|
431
|
+
for (const rel of binFiles) {
|
|
432
|
+
const dest = path.join(dir, rel)
|
|
433
|
+
fs.mkdirSync(path.dirname(dest), { recursive: true })
|
|
434
|
+
fs.copyFileSync(path.join(binBase, rel), dest)
|
|
435
|
+
if (!fs.readFileSync(dest).equals(fs.readFileSync(path.join(binBase, rel)))) return false
|
|
436
|
+
}
|
|
437
|
+
return hasTextPatch || binFiles.length > 0
|
|
438
|
+
}
|
|
439
|
+
|
|
440
|
+
function mount(p) {
|
|
441
|
+
const entry = path.join(NM, p.name)
|
|
442
|
+
const shadow = shadowDir(p.slug)
|
|
443
|
+
const orig = origDir(p.slug)
|
|
444
|
+
fs.rmSync(shadow, { recursive: true, force: true })
|
|
445
|
+
fs.mkdirSync(SHADOWS, { recursive: true })
|
|
446
|
+
// 克隆原版(APFS clonefile,近乎零成本;失败退回普通复制)
|
|
447
|
+
let cp = run('cp', ['-Rc', entry + '/', shadow])
|
|
448
|
+
if (cp.status !== 0) cp = run('cp', ['-R', entry + '/', shadow])
|
|
449
|
+
if (cp.status !== 0) {
|
|
450
|
+
fs.rmSync(shadow, { recursive: true, force: true })
|
|
451
|
+
return { ok: false, error: `copy failed: ${(cp.stderr || '').slice(0, 200)}` }
|
|
452
|
+
}
|
|
453
|
+
// 副本在 profile 树外:补 node_modules 软链指回 profile,平铺依赖沿此可达
|
|
454
|
+
const shadowNm = path.join(shadow, 'node_modules')
|
|
455
|
+
if (!fs.existsSync(shadowNm)) fs.symlinkSync(NM, shadowNm)
|
|
456
|
+
if (!patchInto(shadow, p)) {
|
|
457
|
+
fs.rmSync(shadow, { recursive: true, force: true })
|
|
458
|
+
return { ok: false, error: 'patch failed on shadow' }
|
|
459
|
+
}
|
|
460
|
+
// 正向确认标记:挂载期间插件管理页的描述里可见「🩹 补丁生效中」;看不到 = 补丁没生效
|
|
461
|
+
try {
|
|
462
|
+
const sp = path.join(shadow, 'package.json')
|
|
463
|
+
const spkg = readJson(sp)
|
|
464
|
+
if (!String(spkg.description || '').includes(MOUNT_MARKER)) {
|
|
465
|
+
spkg.description = `${spkg.description || ''} ${MOUNT_MARKER}`.trim()
|
|
466
|
+
fs.writeFileSync(sp, JSON.stringify(spkg, null, 2) + '\n')
|
|
467
|
+
}
|
|
468
|
+
} catch {}
|
|
469
|
+
// 换挂载:原版挪进 orig/,条目换成指向副本的软链
|
|
470
|
+
fs.mkdirSync(path.dirname(orig), { recursive: true })
|
|
471
|
+
fs.rmSync(orig, { recursive: true, force: true })
|
|
472
|
+
fs.renameSync(entry, orig)
|
|
473
|
+
fs.symlinkSync(shadow, entry)
|
|
474
|
+
const state = readState()
|
|
475
|
+
writeState({ swaps: { ...(state.swaps || {}), [p.name]: { shadow, orig, at: new Date().toISOString() } } })
|
|
476
|
+
return { ok: true }
|
|
477
|
+
}
|
|
478
|
+
|
|
479
|
+
function applyOne(p, { dryRun, force }) {
|
|
480
|
+
const r = { name: p.name, patchVersion: p.version }
|
|
481
|
+
const entry = path.join(NM, p.name)
|
|
482
|
+
if (!fs.existsSync(entry) && !fs.existsSync(origDir(p.slug))) {
|
|
483
|
+
r.status = 'missing-target'
|
|
484
|
+
return r
|
|
485
|
+
}
|
|
486
|
+
r.enabled = isEnabled(p.name)
|
|
487
|
+
r.mounted = isMounted(p.name, p.slug)
|
|
488
|
+
r.installedVersion = installedVersion(p.name)
|
|
489
|
+
r.versionMatch = r.installedVersion === p.version
|
|
490
|
+
if (!r.enabled) {
|
|
491
|
+
if (r.mounted && !dryRun) dismount(p) // 禁用 = 恢复原插件 + 清副本
|
|
492
|
+
r.mounted = false
|
|
493
|
+
r.status = 'disabled'
|
|
494
|
+
return r
|
|
495
|
+
}
|
|
496
|
+
if (r.versionMatch === false && !force) {
|
|
497
|
+
// 版本不匹配:确保没挂着旧副本(保底清除已处理,这里只是保险)
|
|
498
|
+
if (r.mounted && !dryRun) dismount(p)
|
|
499
|
+
r.mounted = false
|
|
500
|
+
r.status = 'version-mismatch'
|
|
501
|
+
return r
|
|
502
|
+
}
|
|
503
|
+
if (r.mounted && !(force && !dryRun)) {
|
|
504
|
+
// 新鲜度校验:补丁文件改过了就重建副本(probe 是 dry-run,只读不写)
|
|
505
|
+
const patchPath = path.join(PATCHES_DIR, p.file)
|
|
506
|
+
if (fs.existsSync(patchPath) && probePatch(shadowDir(p.slug), patchPath) !== 'applied') {
|
|
507
|
+
if (!dryRun) {
|
|
508
|
+
dismount(p)
|
|
509
|
+
const m = mount(p)
|
|
510
|
+
r.status = m.ok ? 'applied-now' : 'apply-failed'
|
|
511
|
+
if (!m.ok) r.error = m.error
|
|
512
|
+
return r
|
|
513
|
+
}
|
|
514
|
+
}
|
|
515
|
+
r.status = 'applied'
|
|
516
|
+
return r
|
|
517
|
+
}
|
|
518
|
+
if (dryRun) {
|
|
519
|
+
r.status = 'not-applied'
|
|
520
|
+
return r
|
|
521
|
+
}
|
|
522
|
+
// force 时即使已挂载也重建副本(补丁文件可能刚被编辑过)
|
|
523
|
+
if (r.mounted) dismount(p)
|
|
524
|
+
const m = mount(p)
|
|
525
|
+
if (!m.ok) {
|
|
526
|
+
r.status = 'apply-failed'
|
|
527
|
+
r.error = m.error
|
|
528
|
+
return r
|
|
529
|
+
}
|
|
530
|
+
r.mounted = true
|
|
531
|
+
r.status = 'applied-now'
|
|
532
|
+
return r
|
|
533
|
+
}
|
|
534
|
+
|
|
535
|
+
function revertOne(p) {
|
|
536
|
+
const r = { name: p.name, patchVersion: p.version }
|
|
537
|
+
r.installedVersion = installedVersion(p.name)
|
|
538
|
+
r.status = dismount(p) ? 'reverted' : 'not-applied'
|
|
539
|
+
return r
|
|
540
|
+
}
|
|
541
|
+
|
|
542
|
+
function collectStatus({ dryRun, force, only }) {
|
|
543
|
+
const results = listPatchFiles()
|
|
544
|
+
.filter((p) => !only || p.name === only)
|
|
545
|
+
.map((p) => applyOne(p, { dryRun, force }))
|
|
546
|
+
const out = { command: dryRun ? 'status' : 'apply', profile: PROFILE, results }
|
|
547
|
+
// 失明检测:看门狗自己没上岗时,status 必须大声说出来(今天的教训)
|
|
548
|
+
if (results.length) {
|
|
549
|
+
const pkg = readJson(path.join(PROFILE, 'package.json'))
|
|
550
|
+
const enabled = (pkg.dsh?.profile?.bundles || []).includes('@alequet/dsh-patchkeeper')
|
|
551
|
+
const noneMounted = results.every((r) => !r.mounted)
|
|
552
|
+
if (!enabled) {
|
|
553
|
+
out.alarm = '🚨 patchkeeper 未启用(不在 bundles 列表):所有补丁正在静默失效!运行 doctor --fix 并重启 DSH'
|
|
554
|
+
} else if (dryRun && noneMounted && results.some((r) => r.versionMatch)) {
|
|
555
|
+
out.alarm = '🚨 有匹配补丁但一个都没挂载——若已重启过 DSH,patchkeeper 可能加载失败,请查日志'
|
|
556
|
+
}
|
|
557
|
+
}
|
|
558
|
+
return out
|
|
559
|
+
}
|
|
560
|
+
|
|
561
|
+
function cmdRevert({ only } = {}) {
|
|
562
|
+
const results = listPatchFiles()
|
|
563
|
+
.filter((p) => !only || p.name === only)
|
|
564
|
+
.map(revertOne)
|
|
565
|
+
return { command: 'revert', profile: PROFILE, results }
|
|
566
|
+
}
|
|
567
|
+
|
|
568
|
+
// ---------- doctor ----------
|
|
569
|
+
|
|
570
|
+
function cmdDoctor({ fix, log }) {
|
|
571
|
+
const issues = []
|
|
572
|
+
const linkPath = path.join(NM, '@alequet/dsh-patchkeeper')
|
|
573
|
+
const pkgFile = path.join(PROFILE, 'package.json')
|
|
574
|
+
const pkg = readJson(pkgFile)
|
|
575
|
+
|
|
576
|
+
if (!fs.existsSync(linkPath)) {
|
|
577
|
+
issues.push('node_modules/@alequet/dsh-patchkeeper 缺失——请通过插件管理页(安装第三方插件)重新安装')
|
|
578
|
+
}
|
|
579
|
+
if (!pkg.dependencies?.['@alequet/dsh-patchkeeper']) {
|
|
580
|
+
issues.push('profile package.json 缺少 @alequet/dsh-patchkeeper 依赖——请通过插件管理页安装')
|
|
581
|
+
}
|
|
582
|
+
const bundles = pkg.dsh?.profile?.bundles || []
|
|
583
|
+
if (!bundles.includes('@alequet/dsh-patchkeeper')) {
|
|
584
|
+
issues.push('profile bundles 列表缺少 @alequet/dsh-patchkeeper')
|
|
585
|
+
if (fix) {
|
|
586
|
+
pkg.dsh.profile.bundles = ['@alequet/dsh-patchkeeper', ...bundles]
|
|
587
|
+
fs.writeFileSync(pkgFile, JSON.stringify(pkg, null, 2) + '\n')
|
|
588
|
+
log?.('已把 @alequet/dsh-patchkeeper 加回 bundles 首位')
|
|
589
|
+
}
|
|
590
|
+
}
|
|
591
|
+
return { command: 'doctor', fixed: !!fix, issues }
|
|
592
|
+
}
|
|
593
|
+
|
|
594
|
+
// ---------- 入口 ----------
|
|
595
|
+
|
|
596
|
+
const args = process.argv.slice(2)
|
|
597
|
+
const command = args.find((a) => !a.startsWith('-')) || 'help'
|
|
598
|
+
const flags = {
|
|
599
|
+
json: args.includes('--json'),
|
|
600
|
+
dryRun: args.includes('--dry-run'),
|
|
601
|
+
fix: args.includes('--fix'),
|
|
602
|
+
force: args.includes('--force'),
|
|
603
|
+
only: args.includes('--pkg') ? args[args.indexOf('--pkg') + 1] : null,
|
|
604
|
+
}
|
|
605
|
+
const log = flags.json ? null : (s) => console.log(s)
|
|
606
|
+
|
|
607
|
+
let out
|
|
608
|
+
switch (command) {
|
|
609
|
+
case 'extract': out = cmdExtract({ only: flags.only, log }); break
|
|
610
|
+
case 'apply': {
|
|
611
|
+
const repaired = ensureCleanMount({ only: flags.only }) // 启动保底清除
|
|
612
|
+
out = collectStatus({ dryRun: false, force: flags.force, only: flags.only })
|
|
613
|
+
if (repaired.length) out.repaired = repaired
|
|
614
|
+
break
|
|
615
|
+
}
|
|
616
|
+
case 'revert': out = cmdRevert({ only: flags.only }); break
|
|
617
|
+
case 'remount': {
|
|
618
|
+
// 调试循环快捷键:摘旧副本 → 按当前补丁重建并挂载
|
|
619
|
+
cmdRevert({ only: flags.only })
|
|
620
|
+
out = collectStatus({ dryRun: false, force: true, only: flags.only })
|
|
621
|
+
break
|
|
622
|
+
}
|
|
623
|
+
case 'status': out = collectStatus({ dryRun: true, force: flags.force, only: flags.only }); break
|
|
624
|
+
case 'list': {
|
|
625
|
+
const cfg = readConfig()
|
|
626
|
+
const state = readState()
|
|
627
|
+
const lastApply = state.lastApply || []
|
|
628
|
+
const swaps = state.swaps || {}
|
|
629
|
+
out = {
|
|
630
|
+
command: 'list',
|
|
631
|
+
patches: listPatchFiles().map((p) => {
|
|
632
|
+
const probe = applyOne(p, { dryRun: true })
|
|
633
|
+
const last = lastApply.find((r) => r.name === p.name)
|
|
634
|
+
return {
|
|
635
|
+
name: p.name,
|
|
636
|
+
version: p.version,
|
|
637
|
+
enabled: cfg[p.name]?.enabled !== false,
|
|
638
|
+
note: cfg[p.name]?.note || '',
|
|
639
|
+
risk: cfg[p.name]?.risk || '',
|
|
640
|
+
files: patchFileList(p),
|
|
641
|
+
installedVersion: probe.installedVersion,
|
|
642
|
+
status: probe.status,
|
|
643
|
+
mounted: !!probe.mounted,
|
|
644
|
+
mountedAt: swaps[p.name]?.at || null,
|
|
645
|
+
// 上次真实挂载留下的错误(probe 是 dry-run,探不到这些)
|
|
646
|
+
lastError: (lastApply && ['apply-failed', 'conflict'].includes(lastApply.status) && (lastApply.error || lastApply.status)) || null,
|
|
647
|
+
}
|
|
648
|
+
}),
|
|
649
|
+
}
|
|
650
|
+
if (out.patches.length) {
|
|
651
|
+
const pkgj = readJson(path.join(PROFILE, 'package.json'))
|
|
652
|
+
if (!(pkgj.dsh?.profile?.bundles || []).includes('@alequet/dsh-patchkeeper')) {
|
|
653
|
+
out.alarm = '🚨 patchkeeper 未启用(不在 bundles 列表):所有补丁正在静默失效!运行 doctor --fix 并重启 DSH'
|
|
654
|
+
} else if (out.patches.every((r) => !r.mounted) && out.patches.some((r) => r.enabled !== false && r.installedVersion === r.version)) {
|
|
655
|
+
out.alarm = '🚨 有匹配补丁但一个都没挂载——若已重启过 DSH,patchkeeper 可能加载失败,请查日志'
|
|
656
|
+
}
|
|
657
|
+
}
|
|
658
|
+
break
|
|
659
|
+
}
|
|
660
|
+
case 'enable':
|
|
661
|
+
case 'disable': {
|
|
662
|
+
const target = flags.only
|
|
663
|
+
if (!target) {
|
|
664
|
+
console.error('用法: ' + command + ' --pkg <包名>')
|
|
665
|
+
process.exit(1)
|
|
666
|
+
}
|
|
667
|
+
const cfg = readConfig()
|
|
668
|
+
cfg[target] = { ...(cfg[target] || {}), enabled: command === 'enable' }
|
|
669
|
+
writeConfig(cfg)
|
|
670
|
+
out = collectStatus({ dryRun: false, force: flags.force, only: target })
|
|
671
|
+
break
|
|
672
|
+
}
|
|
673
|
+
case 'risk': {
|
|
674
|
+
const rest = []
|
|
675
|
+
for (let i = args.indexOf('risk') + 1; i < args.length; i++) {
|
|
676
|
+
if (args[i] === '--pkg') { i++; continue }
|
|
677
|
+
if (!args[i].startsWith('-')) rest.push(args[i])
|
|
678
|
+
}
|
|
679
|
+
const riskText = rest.join(' ')
|
|
680
|
+
if (!flags.only) {
|
|
681
|
+
console.error('用法: risk --pkg <包名> [风险说明](省略说明=清除)')
|
|
682
|
+
process.exit(1)
|
|
683
|
+
}
|
|
684
|
+
const cfg = readConfig()
|
|
685
|
+
cfg[flags.only] = { ...(cfg[flags.only] || {}), risk: riskText }
|
|
686
|
+
writeConfig(cfg)
|
|
687
|
+
out = { command: 'risk', name: flags.only, risk: riskText }
|
|
688
|
+
break
|
|
689
|
+
}
|
|
690
|
+
case 'note': {
|
|
691
|
+
const rest = []
|
|
692
|
+
for (let i = args.indexOf('note') + 1; i < args.length; i++) {
|
|
693
|
+
if (args[i] === '--pkg') { i++; continue } // 跳过 --pkg 及其值
|
|
694
|
+
if (!args[i].startsWith('-')) rest.push(args[i])
|
|
695
|
+
}
|
|
696
|
+
const noteText = rest.join(' ')
|
|
697
|
+
if (!flags.only || !noteText) {
|
|
698
|
+
console.error('用法: note --pkg <包名> <效果说明>')
|
|
699
|
+
process.exit(1)
|
|
700
|
+
}
|
|
701
|
+
const cfg = readConfig()
|
|
702
|
+
cfg[flags.only] = { ...(cfg[flags.only] || {}), note: noteText }
|
|
703
|
+
writeConfig(cfg)
|
|
704
|
+
out = { command: 'note', name: flags.only, note: noteText }
|
|
705
|
+
break
|
|
706
|
+
}
|
|
707
|
+
case 'doctor': out = cmdDoctor({ fix: flags.fix, log }); break
|
|
708
|
+
default:
|
|
709
|
+
console.log('用法: extract | apply [--force] | remount | revert | status | list | doctor [--fix] [--json] [--pkg <name>]')
|
|
710
|
+
process.exit(command === 'help' ? 0 : 1)
|
|
711
|
+
}
|
|
712
|
+
|
|
713
|
+
if (command === 'apply' || command === 'remount') {
|
|
714
|
+
writeState({ ts: new Date().toISOString(), lastApply: out.results })
|
|
715
|
+
}
|
|
716
|
+
|
|
717
|
+
if (flags.json) {
|
|
718
|
+
console.log(JSON.stringify(out, null, 2))
|
|
719
|
+
} else if (command === 'apply' || command === 'status' || command === 'revert' || command === 'remount') {
|
|
720
|
+
const icon = {
|
|
721
|
+
'applied-now': '✓ 已挂载副本', applied: '· 副本已挂载', 'not-applied': '○ 未挂载',
|
|
722
|
+
conflict: '✗ 冲突', 'missing-target': '✗ 目标缺失', 'apply-failed': '✗ 挂载失败',
|
|
723
|
+
empty: '- 空补丁', 'version-mismatch': '⊘ 版本不匹配,已跳过', disabled: '⏸ 已禁用',
|
|
724
|
+
reverted: '✓ 已恢复原版', 'revert-failed': '✗ 恢复失败',
|
|
725
|
+
}
|
|
726
|
+
if (out.alarm) console.log(`\n${out.alarm}\n`)
|
|
727
|
+
for (const r of out.results) {
|
|
728
|
+
const vm = r.versionMatch === false ? ` (补丁 ${r.patchVersion} ≠ 已装 ${r.installedVersion})` : ''
|
|
729
|
+
console.log(`${icon[r.status] || r.status} ${r.name}${vm}`)
|
|
730
|
+
}
|
|
731
|
+
const skipped = out.results.filter((r) => r.status === 'version-mismatch')
|
|
732
|
+
if (skipped.length && command !== 'revert') {
|
|
733
|
+
console.log(`\n${skipped.length} 个补丁因版本不匹配被跳过(适配后用 extract 重建;硬打可用 apply --force)`)
|
|
734
|
+
}
|
|
735
|
+
const bad = out.results.filter((r) => ['conflict', 'missing-target', 'apply-failed', 'revert-failed'].includes(r.status))
|
|
736
|
+
if (bad.length) {
|
|
737
|
+
console.log(`\n${bad.length} 个补丁需要人工处理,reject 文件见 ${REJECTS_DIR}`)
|
|
738
|
+
process.exitCode = 2
|
|
739
|
+
}
|
|
740
|
+
} else if (command === 'list') {
|
|
741
|
+
for (const p of out.patches) {
|
|
742
|
+
const flag = p.enabled ? (p.mounted ? '✓ 挂载中' : '○ 未挂载') : '⏸ 已禁用'
|
|
743
|
+
console.log(`${flag} ${p.name}@${p.version}${p.note ? ' —— ' + p.note : ''}`)
|
|
744
|
+
}
|
|
745
|
+
if (!out.patches.length) console.log('(还没有补丁,先跑 extract)')
|
|
746
|
+
} else if (command === 'doctor') {
|
|
747
|
+
if (!out.issues.length) console.log('注册状态正常 ✓')
|
|
748
|
+
else for (const i of out.issues) console.log((out.fixed ? '已修复: ' : '问题: ') + i)
|
|
749
|
+
}
|