ygc-dsh-plugin-autoupdate 0.7.0 → 0.9.1

package/README.md

@@ -32,20 +32,96 @@
 
 **插件不自己改 `cordis.patch.yml`，不卸载任何插件，不碰 `~/.dsh/workbuddy-vault`。**
 
+> 括号里的「不卸载插件」是 0.7.x 及更早的边界。0.8.0 起**新增了受控卸载**，
+> 见下面「卸载插件」一节：只卸 profile 自装且宿主判定 removable 的包，走宿主官方接口。
+
 ## 自动重启怎么做的
 
-不自杀。插件调用时只是把重启助手以 detached 方式拉起来（`ELECTRON_RUN_AS_NODE=1`），
-由助手负责：
+**两条通道，官方优先。**
+
+### 通道一：宿主优雅重启（首选）
+
+宿主若暴露 `desktopRuntime.requestRestart()`（`ctx.get('desktopRuntime')` 或
+`ctx.get('desktopActions')`），插件直接调它。桌面 shell 自己 `app.relaunch()` 并无确认退出，
+把这次退出当作**预期内**的退出，因此**不会弹「启动失败」恢复框、不写 crash report**。
 
-1. 等 `restartDelaySeconds`（默认 10 秒）
-2. 等旧宿主进程退出（最多 15 秒）
-3. 清掉同名残留进程（排除自己）
+### 通道二：进程树之外的助手（兜底）
+
+拿不到官方通道时才走这条。插件不自杀——它把重启助手**送到调用树之外**，由助手负责：
+
+1. 等 `restartDelaySeconds`（默认 0 秒）
+2. **等旧 Electron main 自己退出**（默认最多 15 秒，`exitWaitMs` 可调）——它自己退了就一步强制动作都不做
+3. 仍没退出，先 `taskkill /PID <main>`（**不带 `/F`**，等于发 WM_CLOSE，走 `app.quit()` 正常收尾）；
+   仍不领情才 `/T /F`
 4. 用 `process.execPath` 重新拉起，Windows 上带 `--updated`（窗口会自己置前台）
+5. 删掉跨进程锁，下一次重启才能正常排期
 
 全程写 `~/.dsh/storages/plugin-autoupdate/restart.log`。
 
+### 0.9.0 修的两条「重启之后 DSH 就没了」（实测复现 + 回归测试）
+
+**故障一：助手是宿主的子进程，被自己的 `/T` 一起杀掉。**
+
+0.8.0 用 `spawn(detached: true)` 拉助手，助手仍然是宿主的**子进程**。随后的
+`taskkill /PID <宿主> /T /F` 会顺着 `ParentProcessId` 把助手一起结束 ——
+日志停在「兜底结束旧宿主 pid=…」，`relaunched` 永远不出现。
+实测确认：`taskkill /T` 连 detached 子进程一起杀。
+
+现在两条路把助手送走：
+
+| 通道 | 父进程 | 说明 |
+|---|---|---|
+| **WMI** `Win32_Process.Create`（首选） | `WmiPrvSE.exe` | 压根不在调用树里，`/T` 走不到 |
+| **两跳孤儿**（WMI 不可用时） | 已退出的第一跳 | 第一跳拉起第二跳后立刻 `exit(0)`，`/T` 顺树找不到它 |
+
+**故障二：结束的是宿主（Host），不是 Electron main。**
+
+插件跑在 Host 里，`process.pid` 是 Host 的 pid：
+
+```
+DeepSeek Harness.exe (main, 13872)
+  ├─ gpu / utility / renderer
+  └─ DeepSeek Harness.exe (Host, 8036)   ← 插件在这里
+```
+
+只杀 Host，main 与 renderer 都还活着；新实例一启动就 `requestSingleInstanceLock()`
+失败并**立刻退出** —— 用户看到「重启之后 DSH 不见了」。
+
+现在 `lib/pidtree.js` 按「同一可执行文件往上爬到根」解析出 main，把它登记成目标 pid。
+仅在 `process.versions.electron` 有值时启用（普通 node 环境里爬 `node.exe` 会爬到无关父进程）；
+解析不出就**只等不杀**，绝不回落到 `process.pid` / `process.ppid`。
+
+**另外两个坑（都有回归测试）：**
+
+- **`ELECTRON_RUN_AS_NODE` 必须显式设。** 助手是用 `DeepSeek Harness.exe <helper.js>`
+  起的，不带这个变量 Electron 会把它当成一个完整 App 启动 —— 结果是又开一个 DSH 窗口、
+  助手永远不执行。`test/restart-electron-env.e2e.mjs` 用真 Electron 验证，
+  `…negative.mjs` 证明该断言不是空的。
+- **WMI 不继承调用方环境。** 实测：父进程设的变量在 WMI 子进程里是空的。
+  所以 launcher 用 `.cmd` 逐行 `set` 白名单（`PATH` / `DSH_HOME` / `DSH_PROFILE` /
+  `DSH_DESKTOP_NODE_EXECUTABLE` / `TEMP` …），payload 也带一份；
+  白名单之外的变量（可能含令牌）不落盘。
+
+**并发**：面板连点或自动更新撞车时，0.8.0 会拉起多个助手互相打架（日志里 9 秒内 3 条
+`scheduled restart`）。现在有进程内冷却（60 秒）+ 跨进程锁文件，第二次请求直接返回
+「已有一个重启在执行中，本次跳过」。
+
+### 为什么绝不按映像名杀进程（0.8.0 修复的实机故障）
+
+Electron 的 main / gpu-process / renderer / utility，以及以 `ELECTRON_RUN_AS_NODE`
+跑起来的宿主，**映像名完全相同**（`DeepSeek Harness.exe`）。0.7.x 在「清掉同名残留进程」
+这一步用 `tasklist /FI "IMAGENAME eq ..."` 取全部同名 pid 再逐个强制结束，实际后果是：
+
+- 把自己的 renderer 一起打死 → `Desktop renderer exited: launch-failed` 崩溃日志
+- 用户看到的是 **DSH 无预警消失、随后自动重开**，完全不像「更新完成后的正常重启」
+
+0.8.0 起助手只认两个明确的 pid：**自己**（`process.pid`，永不动）与
+**调用方登记的旧宿主**（`mainPid`）。这条边界由 `test/restart-safety.test.mjs`
+以源码契约钉死（`tasklist` 不得出现 `IMAGENAME`、`taskkill` 必须带 `/PID` 且不得带 `/IM`）。
+
 「只在没有会话正在跑的时候重启」默认开着：判定依据是最近 90 秒内有没有会话事件。
-有会话时重启会被推迟，等空闲了再执行。
+有会话时重启会被推迟，等空闲了再执行。**手动卸载与手动重启不受这条约束。**
+
 
 ## 状态文件
 
@@ -96,8 +172,49 @@
 | POST | `/restart` | 立即重启 |
 | GET | `/backups` | 列出清单备份 |
 | POST | `/restore` | 用某份备份回滚清单 |
+| GET | `/removable` | 哪些插件能卸（透传宿主 `removable` / `availability`） |
+| POST | `/uninstall` | 卸载一个插件（body: `{ name, confirm: true }`） |
 | GET | `/diagnose` | 看插件识别结果（排查「为什么某个包没被检查」） |
 
+## 卸载插件（0.8.0 新增）
+
+桌面 profile 下一个插件同时躺在**三处状态**里，漏掉任何一处都会留下
+「卸了但行为还在」或「UI 里没了却仍在加载」的半成品：
+
+1. `package.json` 的 `dependencies`
+2. `dsh.profile.bundles`（不在这里就不会被加载）
+3. `cordis.patch.yml` 里针对它的补丁行
+
+所以卸载**只走宿主官方 `pluginManager.removeBundle(name)`**：它一次做完
+「摘选 bundle → `pnpm remove` → 重新发布并 reload 加载树」。本插件绝不自己去改
+这三个文件（自己改最容易漏，而且和宿主内存状态不同步）。
+
+### 什么能卸、什么不能
+
+| 情形 | 结果 |
+|---|---|
+| `availability === 'profile'` 且 `removable === true` | 可卸 |
+| `availability === 'installation'`（随 DSH 安装提供） | 拒绝，说明原因 |
+| `removable !== true`（正在运行 / 宿主只读） | 拒绝，回显宿主的 `readOnlyReason` |
+| 本插件自身 `ygc-dsh-plugin-autoupdate` | 拒绝，避免把自动更新器自己拆了 |
+| `@deepseek-ai/dsh-plugin-manager` | 拒绝，卸掉后整个插件体系都加载不了 |
+| 宿主没提供 `pluginManager` | 拒绝，明确告知改用 DSH 自带插件管理 |
+
+### 三条硬约束
+
+1. **必须显式确认**：`POST /uninstall` 没有 `confirm: true` 一律不执行；
+   面板上的按钮会先弹二次确认，取消就什么都不做。
+2. **不可卸载时按钮置灰并说明原因**：信息未知（拿不到宿主清单）时也置灰——
+   宁可点不了，也不让用户点了才发现不行。
+3. **卸载后自动重启生效**：模块已经加载进宿主内存，不重启不会真的消失。
+   走的是与自动更新**同一条**重启通道（优雅优先），不另写一套杀进程逻辑。
+
+### 卸载 → 重启用哪条路
+
+与「自动重启怎么做的」完全一致：优先 `desktopRuntime.requestRestart()`，
+拿不到才用分离助手。卸载时**不受「只在空闲时重启」约束**——
+这是用户当前主动发起的操作，不会打断别人的长任务还装作没发生。
+
 ## 插件共享（特征文件夹）
 
 把「我这台机器装了什么插件」沉淀成一份可以给别人看的东西，互相补全。
@@ -228,26 +345,53 @@ $node = "C:\DeepSeekHarness\resources\runtime\primary-runtime\dependencies\node\
 & $node "C:\DSH-Work\plugin-autoupdate\pkg\test\all.mjs"
 ```
 
-八个套件：
+十六个套件：
 
 | 套件 | 覆盖 |
 |---|---|
 | `selftest.mjs` | 版本比较（含 prerelease）、状态规范化夹紧、延迟判定、registry packument 解析、本机 profile 识别 |
 | `workspace-merge.test.mjs` | `pnpm-workspace.yaml` 的 `minimumReleaseAgeExclude` 合并（同名并成一行、不重复、CRLF 保持、段落连续） |
 | `api-smoke.test.mjs` | 用假 ctx 真加载 Host 半，走完全部 API 路由；状态写在临时 HOME，不碰真实 profile |
+| `snapshot-regression.test.mjs` | 面板快照结构回归 |
+| `update-guard.test.mjs` | 只向上更新、来源判定、发布年龄门槛 |
+| `git-source.test.mjs` | Git 来源的 commit 比较与安装 spec |
 | `machine.test.mjs` | 本机标识：继承会话同步的 machineId、固定后不漂移、改名不换特征值、卸载会话同步后旧值仍有效、写边界（别人的格 / `../` 逃逸 / 前缀相近） |
 | `share.test.mjs` | 特征文件夹：清单分类（registry 只写名 / 本地打副本 / 宿主自带不写）、tgz 结构、同步幂等与副本复用、他人清单合并去重、安装路径选择、特征名防上跳 |
+| `schedule.test.mjs` | 定时排期：更新与共享同步各自独立开关 |
+| `restart-safety.test.mjs` | **重启安全契约**（源码级）：不得按映像名杀进程、必须排除自身、必须先等再兜底、助手须由 WMI/两跳送出进程树、须先礼后兵、须有冷却与锁、launcher 须设 `ELECTRON_RUN_AS_NODE` |
+| `pidtree.test.mjs` | **进程树解析**（合成进程表）：Host 爬到 main、renderer 爬到同一个 main、起点缺失/父进程缺失/链过深时的边界、只在 Electron 里才爬 |
+| `restart-helper-behavior.test.mjs` | **助手行为**（真子进程）：旧 main 自退时零强制动作、不退出时先请求正常退出再强杀、只针对登记的那个 pid、payload 读后即删 |
+| `restart-relaunch.e2e.mjs` | **重启链路**（真进程树）：助手父进程不是调用方、整树 `taskkill /T /F` 之后助手仍活着并完成 `relaunched` |
+| `restart-env.e2e.mjs` | **环境传递**：`DSH_PROFILE` / `DSH_HOME` / `PATH` 传到新实例、白名单外的变量不落盘、新实例不带 `ELECTRON_RUN_AS_NODE` |
+| `restart-electron-env.e2e.mjs` | **Electron 助手模式**（真 Electron exe）：launcher 能真的让 Electron 以 Node 模式跑脚本 |
+| `restart-electron-env.negative.mjs` | **负向对照**：故意不带 `ELECTRON_RUN_AS_NODE` 时脚本不执行，证明上一条断言不是空的 |
+| `uninstall.test.mjs` | **卸载契约**：未确认不出手、`installation`/不可移除的拒绝、拒绝卸自己与管理器、走 `removeBundle`、失败写 `uninstall-failed`、成功后请求重启；外加前端按钮 / 二次确认 / `canUninstall` 契约 |
 | `client-smoke.test.mjs` | 在 Node 里用假 `document` / React 求值 `client.js`，验证插槽注册、locale 注册、面板首渲染 |
 
+真机取证脚本（不属于 `all.mjs`，需要手工跑）：
+
+```powershell
+# 在真宿主进程树里跑一次解析，确认能指出 Electron main
+$env:ELECTRON_RUN_AS_NODE = '1'
+& "C:\DeepSeekHarness\DeepSeek Harness.exe" "C:\DSH-Work\plugin-autoupdate\pkg\test\_live-pidtree.mjs"
+```
+
 ## 边界
 
-- 只**更新**已装插件，不安装新插件、不卸载插件
+- 只**更新**已装插件，不安装新插件；**卸载仅限 profile 自装且宿主判定 removable 的包**（见「卸载插件」）
 - 只在 `registry` 来源上工作；`local` / `git` / `installation` 来源只显示、不处理
 - 更新失败只记历史，不自动回滚（避免把用户自己手改的清单吞掉）；要回滚用 `/restore`
 - DSH 关闭期间不检查（进程内定时器的固有限制）；重开后会立刻按上游发布时间重新判定
 - 共享只**同步清单与副本**，不自动安装别人的插件；安装必须人工点选
 - 只写 `插件库\<本机标识>\` 那一格，别人的格子只读（写入口有守卫）
 - 不在插件库根下留任何公共文件或公共目录
+- **重启只认显式 pid**：任何「按映像名清场」的写法都是回归，`restart-safety.test.mjs` 会红
+- **重启助手必须活在进程树之外**：`spawn(detached)` 逃不掉 `taskkill /T`（实测），
+  任何退回「直接 spawn 助手」的改动都会让 0.9.0 的故障复活
+- **要结束的是 Electron main**：插件里的 `process.pid` 是 Host，
+  只杀 Host 等于没重启。目标 pid 只能来自 `lib/pidtree.js` 的解析结果或调用方显式登记
+- **没有可信 pid 就只等不杀**：绝不回落到 `process.pid` / `process.ppid`
+- **launcher 必须设 `ELECTRON_RUN_AS_NODE=1`**：否则 Electron 把助手脚本当 App 启动
 
 ## 踩过的坑
 

package/client.js

@@ -26,6 +26,8 @@ const CSS = `
 .pau-btn:disabled{opacity:.45;cursor:not-allowed}
 .pau-btn-primary{background:var(--dsw-alias-brand-primary,#2563eb);border-color:transparent;color:#fff}
 .pau-btn-sm{padding:3px 10px;font-size:12px}
+.pau-btn-danger{border-color:var(--dsw-alias-border-danger,#e5484d);color:var(--dsw-alias-label-danger,#c62a2f)}
+.pau-btn-danger:hover:not(:disabled){background:var(--dsw-alias-bg-danger,#fef2f2)}
 .pau-input{font:inherit;font-size:13px;padding:6px 9px;border-radius:8px;border:1px solid var(--dsw-alias-border-l2,#ddd);background:var(--dsw-alias-bg-layer-1,#fff);color:var(--dsw-alias-label-primary,#111);min-width:0;box-sizing:border-box}
 .pau-input-num{width:76px}
 .pau-select{font:inherit;font-size:13px;padding:6px 9px;border-radius:8px;border:1px solid var(--dsw-alias-border-l2,#ddd);background:var(--dsw-alias-bg-layer-1,#fff);color:var(--dsw-alias-label-primary,#111)}
@@ -467,6 +469,45 @@ function makePanel(React) {
           },
           '刷新',
         ),
+        h(
+          'button',
+          {
+            className: 'pau-btn pau-btn-sm pau-btn-danger',
+            // 只有宿主明确说 removable 才让点：信息未知时宁可置灰，也不让用户点了才发现不行
+            disabled: !!busy || !plugin.canUninstall,
+            title: plugin.canUninstall
+              ? `从 profile 卸载 ${plugin.name}（会先二次确认；卸载后自动重启生效）`
+              : plugin.uninstallBlockedReason || '不能卸载',
+            onClick: () => {
+              if (typeof window !== 'undefined' && typeof window.confirm === 'function') {
+                const ok = window.confirm(
+                  `确定要卸载 ${plugin.name}${plugin.version ? ` v${plugin.version}` : ''} 吗？\n\n` +
+                    '这会把它从 profile 的依赖与插件清单里移除，并自动重启 DSH 才生效。\n' +
+                    '（卸载前会自动备份 profile 的 package.json / pnpm-lock.yaml / pnpm-workspace.yaml）',
+                );
+                if (!ok) {
+                  setNote('已取消卸载');
+                  return Promise.resolve(null);
+                }
+              }
+              return run(`uninstall:${plugin.name}`, async () => {
+                const next = await call('/uninstall', { name: plugin.name, confirm: true });
+                const result = next.result || {};
+                if (result.ok) {
+                  setNote(
+                    result.restart && result.restart.ok
+                      ? `${plugin.name} 已卸载，正在重启生效`
+                      : `${plugin.name} 已卸载；请手动完全退出 DSH 再重开`,
+                  );
+                } else {
+                  setNote(result.message || '卸载未完成');
+                }
+                return next;
+              });
+            },
+          },
+          busy === `uninstall:${plugin.name}` ? '卸载中…' : '卸载',
+        ),
       );
     };
 

package/index.js

@@ -34,7 +34,8 @@ import {
 import { normalizeRegistry, probePackage, queryLatest } from './lib/registry.js';
 import { parseLockGitCommit, queryCommitMessage, queryGitHead, queryLatestTag } from './lib/gitref.js';
 import { backupProfile, installSpec, installVersion } from './lib/updater.js';
-import { scheduleRestart } from './lib/restart.js';
+import { gracefulHost, scheduleRestart } from './lib/restart.js';
+import { createUninstall } from './lib/uninstall.js';
 import { createApi } from './lib/api.js';
 import { installSharedPlugin, libraryRoot, shareSnapshot, syncMyFeature, writeAggregate } from './lib/share.js';
 import { resolveIdentity } from './lib/machine.js';
@@ -556,7 +557,22 @@ export function apply(ctx, config = {}) {
     }
   };
 
-  /** 请求重启（受「只在空闲时重启」约束）。 */
+  /**
+   * 请求重启（受「只在空闲时重启」约束）。
+   *
+   * 两条通道，优先官方：
+   *   1. graceful：宿主若暴露 `desktopRuntime.requestRestart()`，走它 ——
+   *      桌面 shell 自己 relaunch 并无确认退出，把这次退出当作预期内的退出，
+   *      **不会弹「启动失败」恢复框、不写 crash report**。
+   *   2. helper：拿不到官方通道才退回「把助手送到进程树之外 → 等旧 main 退出 →
+   *      先请它正常退、必要时定向强杀 → 拉起新实例」。
+   *
+   * 0.9.0 修的两条真故障（见 lib/restart.js 顶部铁律）：
+   *   - 助手原来是被 spawn 出来的**子进程**，`taskkill /T` 会连它一起杀掉，
+   *     日志停在「兜底结束旧宿主」就没了下文（DSH 重启后消失）；
+   *   - 原来结束的是宿主（Host）而不是 Electron main，main 还活着，
+   *     新实例一启动就被单实例锁挡回去。
+   */
   const requestRestart = (why, stateMaybe) => {
     const state = stateMaybe || loadState();
     if (state.restartOnlyWhenIdle && isBusy()) {
@@ -567,11 +583,13 @@ export function apply(ctx, config = {}) {
       return { ok: false, deferred: true, message: '有会话正在跑，等空闲后重启' };
     }
     restartPendingReason = '';
-    const answer = scheduleRestart({
-      delaySeconds: state.restartDelaySeconds,
-      omitArgs: true,
-      reason: why,
-    });
+    const answer =
+      gracefulHost(ctx) ||
+      scheduleRestart({
+        delaySeconds: state.restartDelaySeconds,
+        omitArgs: true,
+        reason: why,
+      });
     const next = loadState();
     pushHistory(next, {
       kind: answer.ok ? 'restart' : 'restart-failed',
@@ -736,6 +754,46 @@ export function apply(ctx, config = {}) {
     runShareSync,
     shareState,
     installFromShare,
+    // 卸载：走宿主官方 pluginManager.removeBundle，本插件不自己改清单/包目录
+    uninstall: createUninstall({
+      getManager: () => {
+        try {
+          return ctx.get('pluginManager');
+        } catch {
+          return undefined;
+        }
+      },
+      requestRestart,
+      log,
+    }),
+    // 面板需要知道「哪些能卸」，直接透传宿主清单里的 removable/availability
+    listRemovable: async () => {
+      let manager;
+      try {
+        manager = ctx.get('pluginManager');
+      } catch {
+        manager = undefined;
+      }
+      if (!manager || typeof manager.listBundles !== 'function') {
+        return { available: false, bundles: [] };
+      }
+      try {
+        const bundles = await manager.listBundles();
+        return {
+          available: true,
+          bundles: (Array.isArray(bundles) ? bundles : []).map((item) => ({
+            name: item?.name,
+            version: item?.version || null,
+            enabled: item?.enabled === true,
+            availability: item?.availability || null,
+            removable: item?.removable === true,
+            readOnlyReason: item?.readOnlyReason || null,
+          })),
+        };
+      } catch (error) {
+        return { available: false, bundles: [], error: String(error?.message || error) };
+      }
+    },
   });
 
   ctx.effect(() =>

package/lib/api.js

@@ -48,6 +48,9 @@ async function readJson(req) {
 function snapshot(deps) {
   const state = loadState();
   const cached = state.lastCheck || {};
+  // 卸载能力：宿主清单里的 removable/availability 决定按钮是否可点。
+  // 同步预取一次（快照本来就是 async 调用方在用），拿不到就整体置灰。
+  const removable = deps._removableCache || null;
   const plugins = deps.listPlugins().map((plugin) => {
     const policy = policyFor(state, plugin.name);
     const pending = state.pending[plugin.name];
@@ -60,6 +63,8 @@ function snapshot(deps) {
     const active = newer ? pending : undefined;
     // git 来源没有版本号可比，可更新性直接看检查阶段算出的 updateAvailable
     const gitNewer = plugin.kind === 'git' ? Boolean(seen && seen.updateAvailable) : false;
+    // 可卸载性：默认不可卸（信息未知时宁可置灰，也不让用户点了才发现不行）
+    const row = removable ? removable.get(plugin.name) : undefined;
     return {
       ...plugin,
       policy: policy.policy,
@@ -73,6 +78,17 @@ function snapshot(deps) {
       updateAvailable: plugin.kind === 'git' ? gitNewer : newer,
       waitMs: active ? delayRemainingMs(state, plugin.name, active.firstSeenAt) : 0,
       waitText: active ? humanHours(delayRemainingMs(state, plugin.name, active.firstSeenAt)) : '',
+      // 面板据此决定「卸载」按钮是否可点，以及鼠标悬停时解释为什么不行
+      canUninstall: Boolean(row && row.removable),
+      uninstallBlockedReason: row
+        ? row.removable
+          ? ''
+          : row.availability === 'installation'
+            ? '随 DSH 安装提供，不能单独卸载'
+            : row.readOnlyReason
+              ? `不可移除（${row.readOnlyReason}）`
+              : '宿主判定为不可移除'
+        : '宿主未提供插件清单，无法卸载',
     };
   });
 
@@ -351,6 +367,26 @@ export function createApi(deps) {
       json(res, 200, { ...snapshot(deps), updated, failed, restart });
     },
 
+    /**
+     * 卸载一个插件。
+     *
+     * body: `{ name, confirm: true }` —— 没有 confirm 一律拒绝执行。
+     * 只卸 profile 自装的、宿主判定 removable 的包；走宿主
+     * `pluginManager.removeBundle`，本插件不自己改 package.json / node_modules。
+     * 成功后自动请求一次重启（模块已加载进内存，不重启不会真的消失）。
+     */
+    'POST /uninstall': async (req, res) => {
+      const body = await readJson(req);
+      const result = await deps.uninstall({ name: body.name, confirm: body.confirm === true, reason: '手动' });
+      json(res, result.ok ? 200 : 400, { ...snapshot(deps), result });
+    },
+
+    /** 哪些插件能卸：透传宿主清单的 removable / availability，供面板置灰与提示。 */
+    'GET /removable': async (req, res) => {
+      const answer = await deps.listRemovable();
+      json(res, 200, { ok: true, ...answer });
+    },
+
     'POST /restart': async (req, res) => {
       const state = loadState();
       const answer = deps.requestRestart('手动重启', { ...state, restartOnlyWhenIdle: false });

package/lib/core.js

@@ -14,7 +14,12 @@ import path from 'node:path';
 import os from 'node:os';
 
 export const STATE_DIR = path.join(os.homedir(), '.dsh', 'storages');
-export const STATE_FILE = path.join(STATE_DIR, 'plugin-autoupdate.json');
+/**
+ * 状态文件位置。允许用环境变量覆盖：
+ * 探针/端到端测试会走真实路由，绝不能把测试记录写进用户真实配置。
+ */
+export const STATE_FILE =
+  process.env.DSH_PLUGIN_AUTOUPDATE_STATE_FILE || path.join(STATE_DIR, 'plugin-autoupdate.json');
 
 /** 默认检查间隔（分钟）。 */
 export const DEFAULT_INTERVAL_MINUTES = 360;

package/lib/pidtree.js

@@ -0,0 +1,115 @@
+/**
+ * 进程树：从「宿主进程」往上找到真正的 **Electron 主进程**。
+ *
+ * ── 为什么需要这个（2026-11-04 二次排障）──────────────────────────────
+ * 本插件跑在 **Host** 里，Host 是 Electron main 以 `ELECTRON_RUN_AS_NODE=1`
+ * 启动的子进程：
+ *
+ *   DeepSeek Harness.exe (main, 例如 13872)
+ *     ├─ gpu-process / utility / renderer
+ *     └─ DeepSeek Harness.exe --expose-internals … (Host, 例如 8036)
+ *          └─ dsh-subprocess-local runner…
+ *
+ * `lib/restart.js` 里 `process.pid` 拿到的是 **Host** 的 pid，不是 main 的。
+ * 0.8.0 只结束 Host → renderer / main 都还活着 → 新实例起来时
+ * `requestSingleInstanceLock()` 失败并立刻退出，用户看到的是
+ * 「重启后 DSH 不见了 / 没起来」，而不是重启。
+ *
+ * main 没有现成的 IPC 能让插件问出来，所以只能按「进程树 + 同一可执行文件」
+ * 往上找：一路向上，直到父进程的可执行文件与本进程**不同**为止，
+ * 那一层就是这棵树的根，也就是 Electron main。
+ *
+ * ── 为什么必须限制跳数 ────────────────────────────────────────────────
+ * 开发/CLI 场景下可执行文件是 `node.exe`，整条链（bash → node → …）同名，
+ * 无上限地往上爬会爬到宿主的父进程甚至用户 shell。
+ * 因此：只对**桌面宿主 exe**启用本函数（调用方判定），并硬性限制 maxHops。
+ */
+
+import { execFileSync } from 'node:child_process';
+
+/** 读取一次全量进程表：pid -> { ppid, exe }。仅 Windows 可用。 */
+function readProcessMap() {
+  if (process.platform !== 'win32') return undefined;
+  // 只取三个字段；ExecutablePath 对受保护进程可能为空，按「未知」处理
+  const script = [
+    "$ErrorActionPreference='Stop';",
+    'Get-CimInstance Win32_Process -Property ProcessId,ParentProcessId,ExecutablePath |',
+    "ForEach-Object { '' + $_.ProcessId + '|' + $_.ParentProcessId + '|' + [string]$_.ExecutablePath }",
+  ].join(' ');
+  let out;
+  try {
+    out = execFileSync(
+      'powershell',
+      ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-Command', script],
+      { encoding: 'utf8', windowsHide: true, timeout: 15000, maxBuffer: 8 * 1024 * 1024 },
+    );
+  } catch {
+    return undefined;
+  }
+  const map = new Map();
+  for (const line of String(out).split(/\r?\n/)) {
+    const text = line.trim();
+    if (!text) continue;
+    const [pidText, ppidText, exeText] = text.split('|');
+    const pid = Number(pidText);
+    if (!Number.isInteger(pid) || pid <= 0) continue;
+    map.set(pid, {
+      ppid: Number(ppidText) || 0,
+      exe: (exeText || '').trim(),
+    });
+  }
+  return map.size ? map : undefined;
+}
+
+const norm = (value) => String(value || '').replace(/\//g, '\\').toLowerCase();
+
+/**
+ * 找到 `startPid` 所在「同一可执行文件」子树的根进程 pid。
+ *
+ * 边界处理（这几种情况含义不同）：
+ *   - 起点自己不在表里 → 无法判定，返回 undefined，让调用方回落；
+ *   - 父进程不在表里（已退出 / 表不全）→ 当前层就是这棵树的根，正常返回；
+ *   - 父进程存在但**可执行文件不同** → 当前层就是根，正常返回；
+ *   - 爬到 maxHops 还没到底 → 判不出来，返回 undefined。
+ *
+ * 实测：本机 Electron main 的父进程（explorer 那层）经常已经不在表里，
+ * 上面第 2 条是**正常路径**，不能当成失败。
+ *
+ * @param {number} startPid 起点（宿主自己的 pid）
+ * @param {string} exePath 期望的可执行文件（宿主 exe，`process.execPath`）
+ * @param {{maxHops?: number, map?: Map<number, {ppid: number, exe: string}>}} [options]
+ * @returns {{root: number, hops: number, chain: number[]}|undefined} 判不出来就返回 undefined
+ */
+export function rootSameExePid(startPid, exePath, options = {}) {
+  const start = Number(startPid);
+  const want = norm(exePath);
+  if (!start || !want) return undefined;
+  const map = options.map || readProcessMap();
+  if (!map) return undefined;
+  const maxHops = Math.max(1, Number(options.maxHops) || 8);
+  if (!map.has(start)) return undefined;
+
+  const chain = [start];
+  let current = start;
+  let hops = 0;
+  while (hops < maxHops) {
+    const entry = map.get(current);
+    if (!entry) break;
+    const parent = map.get(entry.ppid);
+    // 父进程查不到（已退出或表不全）或者可执行文件不同 —— 当前这一层就是根
+    if (!parent || norm(parent.exe) !== want) return { root: current, hops, chain };
+    current = entry.ppid;
+    chain.push(current);
+    hops += 1;
+  }
+  // 爬到上限还没找到底：这条链不干净，不猜
+  return undefined;
+}
+
+/** 仅供测试/诊断：把进程表转成普通对象，避免把 Map 直接抛给日志。 */
+export function describePid(pid, options = {}) {
+  const map = options.map || readProcessMap();
+  if (!map) return undefined;
+  const entry = map.get(Number(pid));
+  return entry ? { pid: Number(pid), ...entry } : undefined;
+}

package/lib/restart-boot.js

@@ -0,0 +1,45 @@
+/**
+ * 两跳孤儿的**第一跳**：拉起真正的重启助手，然后立刻退出。
+ *
+ * ── 为什么需要它（2026-11-04 实测）────────────────────────────────────
+ * `spawn(detached:true)` **不能**让子进程逃出 `taskkill /T`：
+ * 实测 `/T` 顺着 ParentProcessId 把 detached 子进程一起杀了
+ * （A 拉起 B，`taskkill /PID A /T /F` 之后 B 也没了）。
+ *
+ * 但「父进程已经退出的孤儿」逃得掉：A 拉起 B 后立刻 exit，B 的父进程
+ * 变成已死的 A，`/T` 从宿主往下遍历根本碰不到 B（实测 B 存活）。
+ *
+ * 所以本文件只干一件事：把第二跳（restart-helper.js）拉起来，然后 die。
+ * 首选通道是 WMI（父进程是 WmiPrvSE，压根不在这棵树里），
+ * 本文件只在 WMI 不可用时作为备用。
+ */
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const payloadFile = process.argv[2];
+if (!payloadFile) process.exit(1);
+
+const HELPER = fileURLToPath(new URL('./restart-helper.js', import.meta.url));
+const exe = process.execPath;
+
+const env = { ...process.env };
+// 第二跳照样是「Electron 以 Node 模式跑脚本」
+env.ELECTRON_RUN_AS_NODE = '1';
+delete env.DSH_PERMISSION_MODE;
+delete env.DSH_SESSION_ID;
+
+try {
+  const child = spawn(exe, [HELPER, payloadFile], {
+    detached: true,
+    stdio: 'ignore',
+    windowsHide: true,
+    env,
+    shell: false,
+  });
+  child.unref();
+} catch {
+  /* 拉不起来就让第二跳不存在；日志会显示没有 helper start */
+}
+
+// 立刻退出：这一退，第二跳就成了孤儿，`taskkill /T` 再也走不到它
+process.exit(0);