@luoshuizhiwei/dsh-desktop-restart 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 luoshuizhiwei
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,124 @@
+# dsh-desktop-restart
+
+给 **DeepSeek Harness 桌面版（Electron）** 用的重启插件：在 设置 → 通用 里加一行按钮，点一下重启整个应用。
+
+和插件市场里那类「重启 dsh web」的插件不同 —— 那些在桌面版里不能用，原因见下。
+
+## 为什么需要它
+
+桌面版的进程模型和终端里的 `dsh web` 完全不同：
+
+```
+DeepSeek Harness.exe            ← Electron 主进程：窗口、托盘、自动更新
+  └── DeepSeek Harness.exe      ← host 子进程（同一个 exe + ELECTRON_RUN_AS_NODE=1）
+        └── 本插件               跑 dsh-desktop-host，监听 127.0.0.1:19387
+```
+
+于是两件事同时成立：
+
+1. **host 自己退出 ≠ 重启应用。** 主进程把子进程退出当成故障，弹「启动失败」恢复框（默认按钮是「重启应用」）——能用，但每次都要人点一下。
+2. **主进程没给插件留重启通道。** 完整的 IPC 只有 `shutdown` / `quit-inspection` / `update-tasks`（主进程 → host）与 `ready` / `fatal` / `shutdown-complete` / `platform-session`（host → 主进程）；渲染进程侧的 `DESKTOP_IPC` 表里也没有 restart。内置的「重启应用与 Host」菜单项只在 development 下加入菜单，而 Windows 上应用菜单栏只有 devTools，托盘菜单只有「打开应用」和「退出」。
+
+所以一键重启只能由**宿主之外**的进程完成。
+
+## 它怎么工作
+
+1. 设置页那一行向本插件自己的宿主路由发一个同源 POST。
+2. 宿主半校验请求、写下交接描述，然后用 `process.execPath`（就是桌面应用本身）+ `ELECTRON_RUN_AS_NODE=1` 拉起一个**分离的 helper**，并立刻回 202。helper 因此不依赖系统 Node，也不依赖 `dsh` 在 PATH 里。
+3. helper 等 1.5 秒让响应先送达浏览器，然后结束 **Electron 主进程** —— 故意不带 `/T`：host 子进程必须活下来，才能在 IPC 断开后走自己的优雅关闭（`application.shutdown`），把会话日志正常落盘。带 `/T` 会把 host 一起强杀，那才会真丢数据。
+4. helper 等主进程消失，再等监听端口释放（用「连接」探测，不用「绑定」—— 试探性绑定恰恰会占住替代进程要用的那个端口）。
+5. 端口迟迟不放时兜底：按映像名清掉残留的桌面进程（helper 自己排除在外）。
+6. helper 用干净的环境拉起新实例 —— 必须去掉 `ELECTRON_RUN_AS_NODE`，否则新的「应用」会以 Node 模式启动，变成一个没有窗口的进程。
+
+## 安装
+
+### 从 npm
+
+```sh
+dsh plugin add @luoshuizhiwei/dsh-desktop-restart
+```
+
+### 从源码
+
+包放在 `~/.dsh/local-plugins/dsh-desktop-restart`，通过 profile 清单挂载：
+
+```jsonc
+// ~/.dsh/profiles/desktop/package.json
+{
+  "dependencies": {
+    "@luoshuizhiwei/dsh-desktop-restart": "link:../../local-plugins/dsh-desktop-restart"
+  },
+  "dsh": { "profile": { "bundles": [ "...", "@luoshuizhiwei/dsh-desktop-restart" ] } }
+}
+```
+
+在较早的桌面版上，`desktop` profile 由 Electron 应用独占管理，`dsh plugin --profile desktop add` 会被拒绝（`profile "desktop" is managed exclusively by the Electron application`），此时需要手工声明依赖与 bundle；`node_modules` 下的对应项是一个指向源码目录的 junction。
+
+装好后**重启一次应用**才会加载 —— 这第一次得手动（插件还没跑起来）。
+
+## 使用
+
+三个入口，都走同一条受守卫的路径：
+
+1. **会话标题栏按钮** —— 会话页抬头右侧的「⟳ 重启」，常驻可见，最顺手；
+2. **斜杠命令** —— 在输入框里打 `/restart-desktop` 回车；
+3. **设置 → 通用 → 重启桌面应用** —— 备用入口。
+
+按钮类入口是两步确认：第一次点击武装（`确认重启？`），5 秒内第二次点击才执行；斜杠命令直接执行。随后页面断开，应用重启，页面在新进程就绪后自行恢复。
+
+## 安全模型
+
+`POST /dsh-desktop-restart/api/restart` 在动手之前完成全部校验：
+
+| 检查 | 拒绝方式 |
+| --- | --- |
+| 方法不是 POST | `405`，带 `Allow: POST` |
+| TCP 对端不是回环地址 | `403` |
+| `Host` 不是回环名字 | `403` |
+| 带 `forwarded` / `x-forwarded-for` / `x-real-ip` | `403` |
+| 无 `Origin` 时 `Sec-Fetch-Site` 不是 `same-origin` | `403` |
+| 有 `Origin` 但其 host 不等于 `Host` | `403` |
+| 当前宿主不是 Electron 桌面版 | `409` |
+| `config.enabled` 为 false | `403` |
+| 已有一次重启在交接中 | `409` |
+
+**为什么无 `Origin` 也放行**：桌面版的页面以 `dsh-app://` 协议装载，页面里的 `fetch('/…')` 由壳层转发到宿主端口，这种转发的请求**不带 `Origin`**。若直接要求 `Origin`，桌面版里这个按钮会永远返回 403 —— 这也正是插件市场里 `dsh-simple-restart` 在桌面版失效的原因之一。所以无 `Origin` 时改为要求其余每一条都成立（回环对端、回环 Host、无代理痕迹、`Sec-Fetch-Site` 缺省或 `same-origin`）。
+
+## 已知限制
+
+- **只适用于 Electron 桌面版。** 在 `dsh web` 上状态路由会如实报 `desktop: false`，重启按钮禁用；这是设计如此，不是故障。
+- **强杀主进程。** 主进程自身的清理（窗口状态、托盘）不会执行。真正要紧的会话数据在 host 进程里，它会优雅关闭。这是「一键」必须付的代价 —— 主进程没暴露任何可请求的重启通道。
+- **DSH 升级后可能失效。** 实现依赖当前的进程模型与 `ELECTRON_RUN_AS_NODE` 约定；若上游改变 host 的启动方式或给主进程加上重启 IPC，应改用官方通道。
+- **只在 Windows 上验证过。**
+
+## 诊断
+
+每次重启的交接描述与 helper 日志写在 `~/.dsh/desktop-restart/`：
+
+```
+restart-<时间戳>.log       helper 的完整诊断
+handoff-<时间戳>.json      这次交接的目标与参数
+```
+
+正常的一次重启，日志形如：
+
+```
+helper started: helper=… host=… main=… port=19387 exe=…\DeepSeek Harness.exe
+ending the Electron main process … without /T, so the host can close gracefully
+taskkill /PID … /F ok
+main process exited
+port 19387 released
+relaunched "…\DeepSeek Harness.exe" as pid …
+```
+
+## 开发
+
+```sh
+node scripts/smoke.mjs
+```
+
+离线冒烟测试：宿主半用桩上下文加载，只验证路由守卫与全部拒绝路径；helper 只走「映像名不匹配」的拒绝分支。**它不会重启任何东西。**
+
+## 许可证
+
+MIT

package/cordis.patch.yml

@@ -0,0 +1,11 @@
+# dsh-desktop-restart bundle patch —— 挂载 host 半。
+#
+# client 半不需要在这里登记：它经 package.json 的 dsh.client 清单被
+# client-modules 扫描发现（platform: web，./client 导出）。
+#
+# 一行，一次挂载。不要在 profile 自己的 cordis.patch.yml 里再 insert 同一个
+# id，否则 boot 会因重复的 loader entry id 失败。
+- insert:
+    - id: dsh-desktop-restart
+      name: "@luoshuizhiwei/dsh-desktop-restart"
+      config: {}

package/lib/client.js

@@ -0,0 +1,265 @@
+/**
+ * Client half of dsh-desktop-restart.
+ *
+ * 提供两个入口，都走宿主半同一条受守卫的重启路径：
+ *
+ * 1. **会话标题栏按钮**（`conversation.session.header.actions`）—— 常驻可见，
+ *    抬头就能按；
+ * 2. **设置 → 通用 那一行** —— 留作备用入口。
+ *
+ * 另外宿主半还注册了 `/restart-desktop` 斜杠命令，在输入框里直接打字即可。
+ *
+ * 和「重启 dsh web」那类插件不同，这里要重启的是 Electron 应用本身，因为
+ * 桌面版里 host 只是主进程的一个子进程 —— host 自己退出只会换来一个
+ * 「启动失败」恢复框，而主进程没有给插件留任何重启通道。宿主半因此把交接
+ * 交给一个分离的 helper（见 lib/helper.cjs）。
+ *
+ * 本文件是包里的 `./client` bundle，格式与所有 web 插件一致：交给
+ * `window.__ModuleLoader__` 的工厂形式，无 import，`require("react")` 由
+ * 打包器提供，导出 plain-Cordis 插件 `{ name, inject, apply }`。
+ */
+
+window.__ModuleLoader__.load({
+	id: "dsh-desktop-restart",
+	factory: (require) => {
+		var module = { exports: {} };
+		var exports = module.exports;
+		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+
+		const React = require("react");
+
+		/** 本包自己的两条宿主路由。 */
+		const RESTART_ROUTE = "/dsh-desktop-restart/api/restart";
+		const STATUS_ROUTE = "/dsh-desktop-restart/api/status";
+		/** 第一次点击「武装」按钮的有效期。 */
+		const CONFIRM_MS = 5000;
+		/** 会话标题栏的加性座位。 */
+		const HEADER_SLOT = "conversation.session.header.actions";
+		/** 通用设置页里加性一行的座位。 */
+		const SETTINGS_SLOT = "settings.general.item";
+		/** 本插件在这两个座位里的 key。 */
+		const ID = "dsh-desktop-restart";
+
+		const FOCUS_RING = { outline: "2px solid var(--dsw-alias-interactive-bg-hover-accent, rgba(77,107,254,.75))", outlineOffset: "-1px" };
+
+		/** 通用设置区自带的行的配方（对齐 Language / Permission 这类内置行）。 */
+		const S = {
+			row: { display: "flex", alignItems: "center", gap: "8px", padding: "16px 0", borderBottom: ".5px solid var(--dsw-alias-border-l2, rgba(127,127,127,.2))" },
+			text: { display: "flex", flexDirection: "column", flex: 1, gap: "4px", minWidth: 0, paddingRight: "48px" },
+			label: { color: "var(--dsw-alias-label-primary, inherit)", fontSize: "14px", fontWeight: 400, lineHeight: "22px" },
+			hint: { fontSize: "12px", lineHeight: "18px", color: "var(--dsw-alias-label-tertiary, rgba(140,140,150,1))" },
+			hintError: { fontSize: "12px", lineHeight: "18px", color: "var(--dsw-alias-state-error-primary, #f85149)" },
+			hintOk: { fontSize: "12px", lineHeight: "18px", color: "var(--dsw-alias-state-success-primary, #3fb950)" },
+			btn: { display: "inline-flex", alignItems: "center", gap: "12px", flex: "none", boxSizing: "border-box", height: "36px", padding: "0 14px", border: "none", borderRadius: "18px", background: "var(--dsw-alias-bg-module-platform, var(--dsw-alias-interactive-bg-hover, rgba(127,127,127,.12)))", color: "var(--dsw-alias-label-primary, inherit)", font: "inherit", fontSize: "14px", lineHeight: "22px", cursor: "pointer", transition: "background .12s ease, color .12s ease" },
+			btnHover: { background: "var(--dsw-alias-interactive-bg-hover, rgba(127,127,127,.18))" },
+			btnDanger: { color: "var(--dsw-alias-state-error-primary, #f85149)" },
+			btnDangerHover: { background: "var(--dsw-alias-interactive-bg-hover-danger, rgba(248,81,73,.14))" },
+			btnBusy: { opacity: .6, cursor: "default" },
+			btnDisabled: { opacity: .45, cursor: "not-allowed" },
+			// 标题栏是紧凑的横排，按钮因此做成小胶囊，不用设置页那种 36px 控件。
+			headerBtn: { display: "inline-flex", alignItems: "center", gap: "5px", flex: "none", boxSizing: "border-box", height: "26px", padding: "0 9px", border: "none", borderRadius: "13px", background: "transparent", color: "var(--dsw-alias-label-secondary, inherit)", font: "inherit", fontSize: "12px", lineHeight: "18px", cursor: "pointer", whiteSpace: "nowrap", transition: "background .12s ease, color .12s ease" },
+			headerBtnHover: { background: "var(--dsw-alias-interactive-bg-hover, rgba(127,127,127,.18))", color: "var(--dsw-alias-label-primary, inherit)" },
+			headerBtnDanger: { background: "var(--dsw-alias-interactive-bg-hover-danger, rgba(248,81,73,.14))", color: "var(--dsw-alias-state-error-primary, #f85149)" },
+		};
+
+		/** 默认提示文案：说明这一行和「重启 dsh web」的区别。 */
+		const DEFAULT_HINT = "重启整个 DeepSeek Harness（桌面应用与它的 host 进程）。改插件或配置后需要重启才生效时用这个。";
+
+		/**
+		 * 问一次宿主：这是不是 Electron 桌面版。
+		 * @returns {Promise<{ desktop: boolean }>} 状态。
+		 */
+		async function fetchStatus() {
+			try {
+				const response = await fetch(STATUS_ROUTE, { method: "GET" });
+				const body = await response.json().catch(() => null);
+				if (response.ok && body) return { desktop: body.desktop === true };
+				return { desktop: false };
+			} catch {
+				return { desktop: false };
+			}
+		}
+
+		/**
+		 * 请宿主排程一次重启。
+		 * @returns {Promise<{ ok: boolean, text: string }>} 要显示的结果。
+		 */
+		async function requestRestart() {
+			let response;
+			try {
+				response = await fetch(RESTART_ROUTE, { method: "POST" });
+			} catch (error) {
+				return { ok: false, text: "请求失败：" + String((error && error.message) || error) };
+			}
+			const body = await response.json().catch(() => null);
+			if (response.ok && body && body.ok === true) {
+				return {
+					ok: true,
+					text: "已排程重启：宿主 pid " + String(body.hostPid) + "，主进程 pid " + String(body.mainPid) + "，交接 helper " + String(body.helperPid) + "。本页即将断开，稍后会自动回来。",
+				};
+			}
+			return { ok: false, text: String((body && body.error) || ("HTTP " + response.status)) };
+		}
+
+		/**
+		 * 两个入口共用的重启动作：挂载时问一次是否桌面版，第一次按下武装，
+		 * 第二次按下才真的重启。
+		 * @param {object | undefined} timer - 客户端 timer 服务，用于让武装态过期。
+		 * @returns {{ phase: string, message: string, desktop: boolean | null, press: Function }} 动作状态。
+		 */
+		function useRestart(timer) {
+			const phasePair = React.useState("idle");
+			const phase = phasePair[0];
+			const setPhase = phasePair[1];
+			const messagePair = React.useState("");
+			const message = messagePair[0];
+			const setMessage = messagePair[1];
+			const desktopPair = React.useState(null);
+			const desktop = desktopPair[0];
+			const setDesktop = desktopPair[1];
+
+			React.useEffect(() => {
+				let live = true;
+				fetchStatus().then((status) => {
+					if (live) setDesktop(status.desktop);
+				}, () => {
+					if (live) setDesktop(false);
+				});
+				return () => { live = false; };
+			}, []);
+
+			const press = () => {
+				if (phase === "restarting" || desktop === false) return;
+				if (phase !== "confirm") {
+					setPhase("confirm");
+					if (timer !== undefined && typeof timer.timeout === "function") {
+						timer.timeout(() => setPhase((current) => (current === "confirm" ? "idle" : current)), CONFIRM_MS);
+					}
+					return;
+				}
+				setPhase("restarting");
+				setMessage("");
+				requestRestart().then((result) => {
+					setPhase(result.ok ? "done" : "error");
+					setMessage(result.text);
+				}, (failure) => {
+					setPhase("error");
+					setMessage(String((failure && failure.message) || failure));
+				});
+			};
+
+			return { phase, message, desktop, press };
+		}
+
+		/**
+		 * 插件主体：注册会话标题栏按钮与设置页那一行，都挂在本插件自己的
+		 * fiber 上，卸载时随之移除。
+		 * @param {object} ctx - 客户端 Cordis 上下文。
+		 */
+		function apply(ctx) {
+			const slots = ctx.get("slots");
+			if (slots === undefined) return;
+			const timer = ctx.get("timer");
+
+			/** 会话标题栏上的常驻按钮：抬头就能按。 */
+			function HeaderRestartButton() {
+				const action = useRestart(timer);
+				const hoverPair = React.useState(false);
+				const hovered = hoverPair[0];
+				const setHovered = hoverPair[1];
+				const focusPair = React.useState(false);
+				const focused = focusPair[0];
+				const setFocused = focusPair[1];
+
+				const unavailable = action.desktop === false;
+				const busy = action.phase === "restarting";
+				const danger = action.phase === "confirm";
+				const style = Object.assign({}, S.headerBtn,
+					danger ? S.headerBtnDanger : null,
+					busy ? S.btnBusy : null,
+					unavailable ? S.btnDisabled : null,
+					focused ? FOCUS_RING : null,
+					(!busy && !unavailable && !danger && hovered) ? S.headerBtnHover : null);
+				const label = busy ? "重启中…" : (danger ? "确认重启？" : (action.phase === "error" ? "重试" : "重启"));
+				const title = action.message !== ""
+					? action.message
+					: (unavailable ? "仅 Electron 桌面版可用" : "重启整个 DeepSeek Harness 桌面应用");
+
+				return React.createElement("button", {
+					type: "button",
+					style: style,
+					disabled: busy || unavailable,
+					title: title,
+					onClick: action.press,
+					onMouseEnter: () => setHovered(true),
+					onMouseLeave: () => setHovered(false),
+					onFocus: () => setFocused(true),
+					onBlur: () => setFocused(false),
+				}, React.createElement("span", { "aria-hidden": "true", style: { fontSize: "13px", lineHeight: 1 } }, "⟳"), label);
+			}
+
+			/** 设置页那一行：标题、说明和两步确认的重启按钮。 */
+			function SettingsRestartRow() {
+				const action = useRestart(timer);
+				const hoverPair = React.useState(false);
+				const hovered = hoverPair[0];
+				const setHovered = hoverPair[1];
+				const focusPair = React.useState(false);
+				const focused = focusPair[0];
+				const setFocused = focusPair[1];
+
+				const unavailable = action.desktop === false;
+				const busy = action.phase === "restarting";
+				const danger = action.phase === "confirm";
+				const style = Object.assign({}, S.btn,
+					danger ? S.btnDanger : null,
+					busy ? S.btnBusy : null,
+					unavailable ? S.btnDisabled : null,
+					focused ? FOCUS_RING : null,
+					(!busy && !unavailable && hovered) ? (danger ? S.btnDangerHover : S.btnHover) : null);
+				const hintStyle = action.phase === "error" ? S.hintError : (action.phase === "done" ? S.hintOk : S.hint);
+				const hint = busy
+					? "正在交接重启…本页马上会断开。"
+					: (action.message !== ""
+						? action.message
+						: (unavailable
+							? "当前宿主不是 Electron 桌面版，这一行只在桌面应用里可用。"
+							: DEFAULT_HINT));
+				const label = busy ? "重启中…" : (danger ? "确认重启？" : (action.phase === "error" ? "重试" : "重启"));
+
+				return React.createElement("div", { style: S.row },
+					React.createElement("div", { style: S.text },
+						React.createElement("span", { style: S.label }, "重启桌面应用"),
+						React.createElement("span", { style: hintStyle }, hint)),
+					React.createElement("button", {
+						type: "button",
+						style: style,
+						disabled: busy || unavailable,
+						title: unavailable ? "仅 Electron 桌面版可用" : "结束 Electron 主进程并拉起新的应用实例（仅同源 loopback 可用）",
+						onClick: action.press,
+						onMouseEnter: () => setHovered(true),
+						onMouseLeave: () => setHovered(false),
+						onFocus: () => setFocused(true),
+						onBlur: () => setFocused(false),
+					}, label));
+			}
+
+			// 会话标题栏：常驻可见的主入口。
+			ctx.effect(() => slots.inject(HEADER_SLOT, () => slots.register({
+				name: HEADER_SLOT,
+				id: ID,
+				order: 60,
+			}, HeaderRestartButton)));
+
+			// 设置 → 通用：备用入口。
+			ctx.effect(() => slots.inject(SETTINGS_SLOT, () => slots.register({
+				name: SETTINGS_SLOT,
+				id: ID,
+				order: 91,
+			}, SettingsRestartRow)));
+		}
+
+		module.exports = { name: ID, inject: ["slots"], apply };
+		return module.exports;
+	}
+});

package/lib/helper.cjs

@@ -0,0 +1,229 @@
+'use strict'
+
+/**
+ * dsh-desktop-restart — 分离 helper。
+ *
+ * 由 host 半用「桌面应用本身 + ELECTRON_RUN_AS_NODE=1」启动，因此不依赖系统
+ * Node，也不依赖 `dsh` 在 PATH 里。它是交接期间唯一能活过宿主的东西，所以
+ * 整件事由它做完：
+ *
+ *   1. 等一小会儿，让 host 的 HTTP 响应先送达浏览器；
+ *   2. 结束 Electron 主进程 —— 故意不带 /T：host 子进程必须活下来，才能在
+ *      IPC 断开后走自己的优雅关闭（`application.shutdown`），把会话日志
+ *      正常落盘。带 /T 会把 host 一起强杀，那才是真的会丢数据；
+ *   3. 等主进程消失，再等监听端口释放（用「连接」探测，不用「绑定」——
+ *      试探性绑定恰恰会占住替代进程要用的那个端口）；
+ *   4. 端口迟迟不放时兜底：按映像名清掉残留的桌面进程（helper 自己排除在外）；
+ *   5. 用干净的环境拉起新实例 —— 必须去掉 ELECTRON_RUN_AS_NODE，否则新的
+ *      「应用」会以 Node 模式启动，变成一个没有窗口的进程。
+ *
+ * 用法：node helper.cjs <handoff.json>
+ * 所有诊断写入 handoff 里指定的 logPath；这个进程的 stdio 是 ignore。
+ */
+
+const { execFileSync, spawn } = require('node:child_process')
+const fs = require('node:fs')
+const net = require('node:net')
+const path = require('node:path')
+
+/** 主进程消失的等待上限。 */
+const MAIN_EXIT_TIMEOUT_MS = 15000
+/** 端口释放的等待上限。 */
+const PORT_FREE_TIMEOUT_MS = 30000
+/** 默认的交接前等待。 */
+const DEFAULT_DELAY_MS = 1500
+
+const handoffPath = process.argv[2]
+if (typeof handoffPath !== 'string' || handoffPath === '') {
+  process.exit(1)
+}
+
+let handoff
+try {
+  handoff = JSON.parse(fs.readFileSync(handoffPath, 'utf8'))
+} catch {
+  process.exit(1)
+}
+
+const mainPid = Number(handoff.mainPid)
+const exe = String(handoff.exe ?? '')
+const hostPid = Number(handoff.hostPid)
+const port = Number(handoff.port)
+const logPath = String(handoff.logPath ?? '')
+const delayMs = Number(handoff.delayMs) > 0 ? Number(handoff.delayMs) : DEFAULT_DELAY_MS
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms))
+
+/** 追加一行诊断。日志不可写时静默——诊断失败不该拖垮重启本身。 */
+function note(line) {
+  try {
+    fs.appendFileSync(logPath, `[${new Date().toISOString()}] ${line}\n`)
+  } catch {
+    /* 没有日志也要继续 */
+  }
+}
+
+/** 进程是否还活着（信号 0 只做存在性检查）。 */
+function alive(pid) {
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * 端口上是否有人监听。
+ * @param {number} p - 端口。
+ * @returns {Promise<boolean>} 有人应答时为 true。
+ */
+function listening(p) {
+  return new Promise((resolve) => {
+    let settled = false
+    const probe = net.connect({ host: '127.0.0.1', port: p })
+    const finish = (value) => {
+      if (settled) return
+      settled = true
+      probe.destroy()
+      resolve(value)
+    }
+    probe.on('connect', () => finish(true))
+    probe.on('error', () => finish(false))
+    probe.setTimeout(500, () => finish(false))
+  })
+}
+
+/**
+ * 强杀一个 pid。
+ * @param {number} pid - 目标。
+ * @returns {boolean} taskkill 是否成功。
+ */
+function killPid(pid) {
+  try {
+    execFileSync('taskkill', ['/PID', String(pid), '/F'], { stdio: 'ignore', windowsHide: true })
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * 解析 tasklist 的 CSV 输出。只取 `"名字","pid"` 这种 ASCII 结构，
+ * 因此中文系统上的提示行不会干扰解析。
+ * @param {string} args - 传给 tasklist 的参数。
+ * @returns {{ image: string, pid: number }[]} 进程列表。
+ */
+function tasklist(args) {
+  try {
+    const out = execFileSync('tasklist', args, { encoding: 'utf8', windowsHide: true })
+    return [...out.matchAll(/"([^"]*)","(\d+)"/gu)]
+      .map((match) => ({ image: match[1], pid: Number(match[2]) }))
+      .filter((entry) => Number.isInteger(entry.pid) && entry.pid > 0)
+  } catch {
+    return []
+  }
+}
+
+/**
+ * 目标 pid 当前的映像名，用于确认它确实是我们要结束的那个进程。
+ * @param {number} pid - 目标。
+ * @returns {string | null} 映像名，或 null。
+ */
+function imageNameOf(pid) {
+  const found = tasklist(['/FI', `PID eq ${String(pid)}`, '/FO', 'CSV', '/NH'])
+    .find((entry) => entry.pid === pid)
+  return found === undefined ? null : found.image
+}
+
+/** 当前所有桌面应用进程（含 helper 自己）。 */
+function applicationPids() {
+  if (exe === '') return []
+  return tasklist(['/FI', `IMAGENAME eq ${path.basename(exe)}`, '/FO', 'CSV', '/NH'])
+    .map((entry) => entry.pid)
+}
+
+/**
+ * 交接并重启。
+ * @returns {Promise<void>} 完成（无论成功或已记录失败）。
+ */
+async function main() {
+  note(`helper started: helper=${process.pid} host=${hostPid} main=${mainPid} port=${port} exe=${exe}`)
+
+  if (!Number.isInteger(mainPid) || mainPid <= 1) {
+    note('refusing: the handoff carries no usable main process id')
+    return
+  }
+  if (exe === '') {
+    note('refusing: the handoff carries no application executable')
+    return
+  }
+
+  // 1. 先让浏览器拿到「已排程重启」的响应。
+  await sleep(delayMs)
+
+  // 2. 确认目标身份，然后结束主进程（不带 /T）。
+  const expected = path.basename(exe).toLowerCase()
+  const image = imageNameOf(mainPid)
+  if (image !== null && image.toLowerCase() !== expected) {
+    note(`refusing: pid ${mainPid} is "${image}", not "${expected}"`)
+    return
+  }
+  if (image === null) {
+    note(`main process ${mainPid} is already gone; skipping the kill`)
+  } else {
+    note(`ending the Electron main process ${mainPid} ("${image}") without /T, so the host can close gracefully`)
+    note(killPid(mainPid) ? `taskkill /PID ${mainPid} /F ok` : `taskkill /PID ${mainPid} /F reported an error`)
+  }
+
+  // 3. 等主进程消失。
+  const goneBy = Date.now() + MAIN_EXIT_TIMEOUT_MS
+  while (Date.now() < goneBy && alive(mainPid)) await sleep(200)
+  note(alive(mainPid) ? `main process still alive after ${MAIN_EXIT_TIMEOUT_MS}ms` : 'main process exited')
+
+  // 4. 等端口释放；迟迟不放就兜底清理残留进程。
+  if (Number.isInteger(port) && port > 0) {
+    const freeBy = Date.now() + PORT_FREE_TIMEOUT_MS
+    while (Date.now() < freeBy && await listening(port)) await sleep(300)
+    if (await listening(port)) {
+      note(`port ${port} is still held; terminating leftover application processes`)
+      for (const pid of applicationPids()) {
+        if (pid === process.pid || pid === mainPid) continue
+        note(`killing leftover pid ${pid}`)
+        killPid(pid)
+      }
+      await sleep(1500)
+    } else {
+      note(`port ${port} released`)
+    }
+  }
+
+  // 5. 给文件系统和端口一点收尾时间，然后拉起新实例。
+  await sleep(800)
+
+  const env = { ...process.env }
+  for (const key of Object.keys(env)) {
+    const upper = key.toUpperCase()
+    // Node 模式下这两个变量会跟着继承；不清掉，新实例会变成一个没有窗口的进程。
+    if (upper === 'ELECTRON_RUN_AS_NODE' || upper === 'DSH_DESKTOP_NODE_EXECUTABLE') delete env[key]
+  }
+
+  try {
+    const child = spawn(exe, [], {
+      detached: true,
+      stdio: 'ignore',
+      windowsHide: false,
+      cwd: path.dirname(exe),
+      env,
+    })
+    child.on('error', (error) => note(`relaunch failed: ${String((error && error.message) || error)}`))
+    child.unref()
+    note(`relaunched "${exe}" as pid ${String(child.pid)}`)
+  } catch (error) {
+    note(`relaunch threw: ${String((error && error.stack) || error)}`)
+  }
+}
+
+main().catch((error) => {
+  note(`helper failed: ${String((error && error.stack) || error)}`)
+})

package/lib/index.js

@@ -0,0 +1,285 @@
+/**
+ * dsh-desktop-restart — Host half.
+ *
+ * 桌面版（Electron）的进程模型和 `dsh web` 完全不同：
+ *
+ *   DeepSeek Harness.exe            ← Electron 主进程：窗口、托盘、更新、spawn host
+ *     └── DeepSeek Harness.exe      ← host 子进程：同一个 exe，ELECTRON_RUN_AS_NODE=1，
+ *           （ELECTRON_RUN_AS_NODE=1）  跑 dsh-desktop-host，监听 127.0.0.1:19387
+ *           └── 本插件就在这里
+ *
+ * 这带来两个后果，它们决定了本插件为什么长这样：
+ *
+ * 1. host 自己退出并不能重启应用。主进程会把子进程退出当成故障，弹出
+ *    「启动失败」恢复框（默认按钮是「重启应用」）——能用，但每次都要人点一下。
+ *
+ * 2. 主进程没有暴露任何「重启」通道给插件。完整的 IPC 表只有
+ *    shutdown / quit-inspection / update-tasks（主进程 → host），
+ *    以及 ready / fatal / shutdown-complete / platform-session（host → 主进程）；
+ *    渲染进程侧的 DESKTOP_IPC 里也没有 restart。内置的「重启应用与 Host」
+ *    菜单项只在 development 下加入菜单，而 Windows 上应用菜单栏只有 devTools，
+ *    托盘菜单只有「打开应用」和「退出」。
+ *
+ * 所以真正的一键重启只能由宿主之外的进程完成：本半只做校验、写一份交接描述，
+ * 然后把工作交给一个分离的 helper（见 lib/helper.cjs），由它结束 Electron
+ * 主进程 —— host 会因 IPC 断开而自行优雅关闭（会话日志正常落盘）—— 等端口
+ * 释放后，用干净的启动环境拉起新的应用实例。
+ *
+ * 安全模型：路由只接受同源 loopback 的 POST（带转发头一律拒绝），非桌面宿主
+ * 直接拒绝并说明原因，同一时刻只允许一次重启交接。
+ *
+ * @module dsh-desktop-restart
+ */
+
+import { spawn } from 'node:child_process'
+import { mkdirSync, writeFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { basename, dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+/** 没有 web carrier 就没有路由：这是唯一的硬依赖。 */
+export const inject = ['webServer']
+
+/** 本插件拥有的两个路由。 */
+const ROUTE_RESTART = '/dsh-desktop-restart/api/restart'
+const ROUTE_STATUS = '/dsh-desktop-restart/api/status'
+
+/** 分离 helper 的绝对路径。 */
+const HELPER_PATH = fileURLToPath(new URL('./helper.cjs', import.meta.url))
+
+/** 交接描述与 helper 日志的落盘位置（与 DSH 自己的 home 保持一致）。 */
+const DSH_HOME = process.env.DSH_HOME ?? join(homedir(), '.dsh')
+const STATE_DIR = join(DSH_HOME, 'desktop-restart')
+
+/** helper 在动手前的等待时间，让 HTTP 响应先送达浏览器。 */
+const HANDOFF_DELAY_MS = 1500
+
+/**
+ * 判断当前 host 是否跑在 Electron 桌面壳下，并取出重启所需的目标。
+ *
+ * 判据全部来自进程本身，不依赖任何环境变量约定：
+ * - `ELECTRON_RUN_AS_NODE=1`：说明这个「node」其实是一个 Electron 可执行文件；
+ * - `process.execPath` 的 basename 不是 node：排除普通的 Node 宿主；
+ * - `process.ppid` 是主进程：桌面壳 spawn host 时就是父子关系。
+ *
+ * 任何一条不成立都返回 null，插件于是只注册状态路由、拒绝重启，绝不误杀进程。
+ * @returns {{ mainPid: number, exe: string, hostPid: number } | null} 重启目标，或 null。
+ */
+function desktopTarget() {
+  if (process.env.ELECTRON_RUN_AS_NODE !== '1') return null
+  const exe = process.execPath
+  if (typeof exe !== 'string' || exe === '') return null
+  const name = basename(exe).toLowerCase()
+  if (name === 'node' || name === 'node.exe') return null
+  const mainPid = process.ppid
+  if (!Number.isInteger(mainPid) || mainPid <= 1) return null
+  return { mainPid, exe, hostPid: process.pid }
+}
+
+/** Host 头是否指向回环地址（含 IPv6 字面量写法）。 */
+function isLoopbackHost(host) {
+  const name = host.startsWith('[') ? host.slice(0, host.indexOf(']') + 1) : host.split(':')[0]
+  return name === '127.0.0.1' || name === 'localhost' || name === '[::1]' || name === '::1'
+}
+
+/** TCP 对端是否就是本机。 */
+function loopbackPeer(req) {
+  const address = req.socket.remoteAddress
+  return address === '127.0.0.1' || address === '::1' || address === '::ffff:127.0.0.1'
+}
+
+/**
+ * 桌面壳转发过来的请求是否可以信任。
+ *
+ * 桌面版的页面是以 `dsh-app://` 协议装载的，页面里的 `fetch('/…')` 由壳层
+ * 转发到 host 的 HTTP 端口 —— 这种转发的请求**没有 Origin 头**。所以无
+ * Origin 不能直接判为不可信，而是要求其余每一条都成立：没有代理痕迹、
+ * Host 是回环名字、TCP 对端是回环地址，且 `Sec-Fetch-Site` 缺省或就是
+ * same-origin（跨站请求会被浏览器标成 cross-site，据此挡掉）。
+ * @param {import('node:http').IncomingMessage} req - 请求。
+ * @returns {boolean} 可信任时为 true。
+ */
+function desktopForwarded(req) {
+  const site = req.headers['sec-fetch-site']
+  if (site !== undefined && site !== 'same-origin') return false
+  if (req.headers.forwarded !== undefined
+    || req.headers['x-forwarded-for'] !== undefined
+    || req.headers['x-real-ip'] !== undefined) return false
+  const host = req.headers.host
+  if (host === undefined || !isLoopbackHost(host)) return false
+  return loopbackPeer(req)
+}
+
+/**
+ * 请求是否来自可信的调用方。
+ *
+ * 两种可信形态：浏览器直接发来的同源请求（Origin 正好是本次请求的
+ * authority），或桌面壳转发来的请求（见 {@link desktopForwarded}）。
+ * 两者都要求 TCP 对端是回环地址。
+ * @param {import('node:http').IncomingMessage} req - 请求。
+ * @returns {boolean} 可信时为 true。
+ */
+function trustedRequest(req) {
+  if (!loopbackPeer(req)) return false
+  const host = req.headers.host
+  if (host === undefined) return false
+  const origin = req.headers.origin
+  if (origin === undefined) return desktopForwarded(req)
+  try {
+    const parsed = new URL(origin)
+    return (parsed.protocol === 'http:' || parsed.protocol === 'https:') && parsed.host === host
+  } catch {
+    return false
+  }
+}
+
+/**
+ * 写交接描述，并拉起分离的 helper。
+ *
+ * helper 用 `process.execPath`（就是桌面应用本身）加 `ELECTRON_RUN_AS_NODE=1`
+ * 启动，因此不依赖系统 Node、也不依赖 `dsh` 在 PATH 里。
+ * @param {{ mainPid: number, exe: string, hostPid: number }} target - 重启目标。
+ * @param {number | null} port - host 正在监听的端口，helper 会等它释放。
+ * @returns {{ hostPid: number, mainPid: number, helperPid: number | undefined, logPath: string }} 交接结果。
+ */
+function scheduleRestart(target, port) {
+  mkdirSync(STATE_DIR, { recursive: true })
+  const stamp = new Date().toISOString().replace(/[:.]/gu, '-').slice(0, 19)
+  const logPath = join(STATE_DIR, `restart-${stamp}.log`)
+  const handoffPath = join(STATE_DIR, `handoff-${stamp}.json`)
+  writeFileSync(handoffPath, JSON.stringify({
+    mainPid: target.mainPid,
+    exe: target.exe,
+    hostPid: target.hostPid,
+    port: port ?? null,
+    logPath,
+    handoffPath,
+    delayMs: HANDOFF_DELAY_MS,
+    startedAt: new Date().toISOString(),
+  }, null, 2), 'utf8')
+
+  const helper = spawn(process.execPath, [HELPER_PATH, handoffPath], {
+    detached: true,
+    stdio: 'ignore',
+    windowsHide: true,
+    cwd: dirname(HELPER_PATH),
+    env: { ...process.env, ELECTRON_RUN_AS_NODE: '1' },
+  })
+  helper.unref()
+  return {
+    hostPid: target.hostPid,
+    mainPid: target.mainPid,
+    helperPid: helper.pid,
+    logPath,
+  }
+}
+
+/**
+ * 挂载插件：一条状态路由 + 一条受守卫的重启路由。
+ * @param {import('@deepseek-ai/cordis').Context} ctx - host 上下文。
+ * @param {{ enabled?: boolean }} [config] - 本插件那一行的 config。
+ */
+export function apply(ctx, config = {}) {
+  const target = desktopTarget()
+  const enabled = config.enabled !== false
+  let scheduled = false
+
+  /**
+   * 排程一次重启。路由与斜杠命令共用这一条路径，因此守卫只需要维护一份。
+   * @returns {{ status: number, body: Record<string, unknown> }} 给调用方的结果。
+   */
+  function scheduleOnce() {
+    if (!enabled) {
+      return { status: 403, body: { ok: false, error: '本插件那一行的 config.enabled 为 false，重启已停用' } }
+    }
+    if (target === null) {
+      return {
+        status: 409,
+        body: { ok: false, error: '当前宿主不是 Electron 桌面版；本插件只负责重启桌面应用，dsh web 请用别的重启方式' },
+      }
+    }
+    if (scheduled) {
+      return { status: 409, body: { ok: false, error: '已经有一次重启在交接中' } }
+    }
+    scheduled = true
+    try {
+      const result = scheduleRestart(target, ctx.webServer.port ?? null)
+      try {
+        ctx.logger('dsh-desktop-restart').info(
+          'restart scheduled: host pid %d, main pid %d, helper pid %s',
+          result.hostPid, result.mainPid, String(result.helperPid),
+        )
+      } catch {
+        /* 日志不可用不影响交接 */
+      }
+      return { status: 202, body: { ok: true, ...result } }
+    } catch (error) {
+      scheduled = false
+      return { status: 500, body: { ok: false, error: String((error && error.message) || error) } }
+    }
+  }
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: ROUTE_STATUS,
+    handler: (req, res) => {
+      const send = (status, body) => {
+        res.writeHead(status, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' })
+        res.end(JSON.stringify(body))
+      }
+      if (req.method !== 'GET') {
+        res.writeHead(405, { allow: 'GET' })
+        res.end()
+        return
+      }
+      send(200, {
+        desktop: target !== null,
+        enabled,
+        hostPid: process.pid,
+        mainPid: target?.mainPid ?? null,
+        exe: target?.exe ?? null,
+      })
+    },
+  }), 'dsh-desktop-restart: status route')
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: ROUTE_RESTART,
+    handler: (req, res) => {
+      const send = (status, body) => {
+        res.writeHead(status, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' })
+        res.end(JSON.stringify(body))
+      }
+      if (req.method !== 'POST') {
+        res.writeHead(405, { allow: 'POST' })
+        res.end()
+        return
+      }
+      if (!trustedRequest(req)) {
+        send(403, { ok: false, error: '重启只接受同源 loopback 请求' })
+        return
+      }
+      const { status, body } = scheduleOnce()
+      send(status, body)
+    },
+  }), 'dsh-desktop-restart: restart route')
+
+  // 斜杠命令：在输入框里打 /restart-desktop 就能重启，不必翻到设置页。
+  // commands 是可选的 —— 没有它时插件照常提供上面两条路由。
+  ctx.inject(['commands'], (commandCtx) => {
+    commandCtx.effect(() => commandCtx.commands.register({
+      name: 'restart-desktop',
+      description: '重启整个 DeepSeek Harness 桌面应用（Electron 应用与它的 host 进程）',
+      handler: () => {
+        const { status, body } = scheduleOnce()
+        if (body.ok === true) {
+          return {
+            kind: 'success',
+            text: `已排程重启：宿主 pid ${String(body.hostPid)}，主进程 pid ${String(body.mainPid)}。窗口会关闭，随后自动打开。`,
+          }
+        }
+        return { kind: 'error', text: String(body.error ?? `重启被拒绝（HTTP ${String(status)}）`) }
+      },
+    }), 'dsh-desktop-restart: /restart-desktop command')
+  })
+}

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@luoshuizhiwei/dsh-desktop-restart",
+  "version": "0.1.0",
+  "description": "DeepSeek Harness 桌面版重启插件：会话标题栏按钮 / 斜杠命令 / 设置页入口，经分离的 helper 重启整个 Electron 应用（而不是只重启 dsh web 进程）。",
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "deepseek-harness",
+    "restart",
+    "desktop",
+    "electron"
+  ],
+  "type": "module",
+  "main": "lib/index.js",
+  "exports": {
+    ".": {
+      "default": "./lib/index.js"
+    },
+    "./client": {
+      "default": "./lib/client.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "scripts",
+    "cordis.patch.yml",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20",
+    "dsh": ">=0.2.0-rc.1"
+  },
+  "scripts": {
+    "test": "node scripts/smoke.mjs",
+    "prepublishOnly": "npm test"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-client-ui-conversation",
+        "@deepseek-ai/dsh-client-ui-settings"
+      ],
+      "platform": "web"
+    }
+  },
+  "license": "MIT",
+  "author": "luoshuizhiwei",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/luoshuizhiwei/dsh-desktop-restart.git"
+  },
+  "bugs": {
+    "url": "https://github.com/luoshuizhiwei/dsh-desktop-restart/issues"
+  },
+  "homepage": "https://github.com/luoshuizhiwei/dsh-desktop-restart#readme"
+}

package/scripts/smoke.mjs

@@ -0,0 +1,265 @@
+/**
+ * dsh-desktop-restart 的离线冒烟测试。
+ *
+ * 刻意不重启任何东西：
+ * - 宿主半用桩上下文加载，只验证路由的守卫与拒绝路径；
+ * - helper 只走「映像名不匹配」的拒绝路径，绝不会走到 taskkill / spawn。
+ *
+ * 运行：node scripts/smoke.mjs
+ */
+
+import assert from 'node:assert/strict'
+import { spawnSync } from 'node:child_process'
+import { mkdtempSync, readFileSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const libDir = fileURLToPath(new URL('../lib/', import.meta.url))
+const helperPath = join(libDir, 'helper.cjs')
+
+let passed = 0
+/** 跑一个断言块并计数。 */
+function ok(name, fn) {
+  fn()
+  passed += 1
+  console.log('  ok   ' + name)
+}
+
+/** 一个最小可用的 node:http 响应桩。 */
+function makeRes() {
+  const res = { statusCode: null, headers: null, body: '' }
+  res.writeHead = (code, headers) => {
+    res.statusCode = code
+    res.headers = headers ?? null
+  }
+  res.end = (chunk) => {
+    res.body = chunk === undefined ? '' : String(chunk)
+  }
+  return res
+}
+
+/** 一个最小可用的请求桩，默认是可信的同源 loopback POST。 */
+function makeReq(method, overrides = {}) {
+  return {
+    method,
+    socket: { remoteAddress: overrides.remoteAddress ?? '127.0.0.1' },
+    headers: {
+      origin: overrides.origin ?? 'http://127.0.0.1:19387',
+      host: overrides.host ?? '127.0.0.1:19387',
+      ...(overrides.headers ?? {}),
+    },
+  }
+}
+
+console.log('host half')
+
+const routes = new Map()
+const commands = []
+/** 桩：命令服务只记录注册，绝不执行任何调度。 */
+const commandsService = {
+  register: (definition) => {
+    commands.push(definition)
+    return () => {}
+  },
+}
+const ctx = {
+  effect: (fn) => {
+    const dispose = fn()
+    return typeof dispose === 'function' ? dispose : undefined
+  },
+  webServer: {
+    port: 19387,
+    register: (spec) => {
+      routes.set(spec.path, spec)
+      return () => routes.delete(spec.path)
+    },
+  },
+  logger: () => ({ info() {}, warn() {}, error() {} }),
+  inject: (deps, cb) => {
+    if (deps.includes('commands')) {
+      cb({
+        effect: (fn) => {
+          const dispose = fn()
+          return typeof dispose === 'function' ? dispose : undefined
+        },
+        commands: commandsService,
+      })
+    }
+  },
+}
+
+const hostHalf = await import(new URL('../lib/index.js', import.meta.url).href)
+hostHalf.apply(ctx, {})
+
+const statusRoute = routes.get('/dsh-desktop-restart/api/status')
+const restartRoute = routes.get('/dsh-desktop-restart/api/restart')
+
+ok('注册了状态与重启两条路由', () => {
+  assert.ok(statusRoute, '缺少状态路由')
+  assert.ok(restartRoute, '缺少重启路由')
+  assert.equal(routes.size, 2)
+})
+
+ok('host 半声明 webServer 依赖', () => {
+  assert.deepEqual(hostHalf.inject, ['webServer'])
+})
+
+ok('斜杠命令：注册了 /restart-desktop', () => {
+  assert.equal(commands.length, 1, '应当恰好注册一个命令')
+  assert.equal(commands[0].name, 'restart-desktop')
+  assert.ok(commands[0].description.length > 0, '描述不能为空')
+  assert.equal(typeof commands[0].handler, 'function')
+})
+
+ok('斜杠命令：非桌面宿主下返回 error 结果', () => {
+  const result = commands[0].handler({})
+  assert.equal(result.kind, 'error')
+  assert.match(result.text, /桌面版/u)
+})
+
+ok('斜杠命令：命令名符合 DSH 的命名规则', () => {
+  assert.match(commands[0].name, /^[a-z][a-z0-9_-]*$/u)
+})
+
+ok('状态路由：GET 返回 desktop=false（当前不是桌面宿主）', () => {
+  const res = makeRes()
+  statusRoute.handler(makeReq('GET'), res)
+  assert.equal(res.statusCode, 200)
+  const body = JSON.parse(res.body)
+  assert.equal(body.desktop, false)
+  assert.equal(body.enabled, true)
+  assert.equal(body.hostPid, process.pid)
+})
+
+ok('状态路由：非 GET 返回 405', () => {
+  const res = makeRes()
+  statusRoute.handler(makeReq('POST'), res)
+  assert.equal(res.statusCode, 405)
+})
+
+ok('重启路由：非 POST 返回 405', () => {
+  const res = makeRes()
+  restartRoute.handler(makeReq('GET'), res)
+  assert.equal(res.statusCode, 405)
+  assert.equal(res.headers.allow, 'POST')
+})
+
+ok('重启路由：非 loopback 来源返回 403', () => {
+  const res = makeRes()
+  restartRoute.handler(makeReq('POST', { remoteAddress: '10.1.2.3' }), res)
+  assert.equal(res.statusCode, 403)
+})
+
+ok('重启路由：带 Origin 时以 Origin 为准（回环对端仍是硬前提）', () => {
+  const res = makeRes()
+  restartRoute.handler(makeReq('POST', { headers: { 'x-forwarded-for': '203.0.113.9' } }), res)
+  assert.equal(res.statusCode, 409)
+})
+
+ok('重启路由：Origin 与 Host 不一致返回 403', () => {
+  const res = makeRes()
+  restartRoute.handler(makeReq('POST', { origin: 'http://evil.example' }), res)
+  assert.equal(res.statusCode, 403)
+})
+
+ok('重启路由：桌面壳转发的无 Origin 请求被放行（走到非桌面判定）', () => {
+  const res = makeRes()
+  const req = makeReq('POST')
+  delete req.headers.origin
+  restartRoute.handler(req, res)
+  assert.equal(res.statusCode, 409)
+})
+
+ok('重启路由：无 Origin 且带转发头返回 403', () => {
+  const res = makeRes()
+  const req = makeReq('POST', { headers: { 'x-forwarded-for': '203.0.113.9' } })
+  delete req.headers.origin
+  restartRoute.handler(req, res)
+  assert.equal(res.statusCode, 403)
+})
+
+ok('重启路由：无 Origin 且 Sec-Fetch-Site 为 cross-site 返回 403', () => {
+  const res = makeRes()
+  const req = makeReq('POST', { headers: { 'sec-fetch-site': 'cross-site' } })
+  delete req.headers.origin
+  restartRoute.handler(req, res)
+  assert.equal(res.statusCode, 403)
+})
+
+ok('重启路由：无 Origin 且 Host 非回环返回 403', () => {
+  const res = makeRes()
+  const req = makeReq('POST', { host: 'example.com' })
+  delete req.headers.origin
+  restartRoute.handler(req, res)
+  assert.equal(res.statusCode, 403)
+})
+
+ok('重启路由：Origin 的 host 与 Host 一致时被放行', () => {
+  const res = makeRes()
+  restartRoute.handler(makeReq('POST', { origin: 'http://localhost:19387', host: 'localhost:19387' }), res)
+  assert.equal(res.statusCode, 409)
+})
+
+ok('重启路由：可信但非桌面宿主返回 409 并说明原因', () => {
+  const res = makeRes()
+  restartRoute.handler(makeReq('POST'), res)
+  assert.equal(res.statusCode, 409)
+  assert.match(JSON.parse(res.body).error, /桌面版/u)
+})
+
+ok('重启路由：config.enabled=false 时返回 403', () => {
+  const disabled = new Map()
+  const disabledCtx = {
+    ...ctx,
+    webServer: {
+      port: 19387,
+      register: (spec) => {
+        disabled.set(spec.path, spec)
+        return () => disabled.delete(spec.path)
+      },
+    },
+  }
+  hostHalf.apply(disabledCtx, { enabled: false })
+  const res = makeRes()
+  disabled.get('/dsh-desktop-restart/api/restart').handler(makeReq('POST'), res)
+  assert.equal(res.statusCode, 403)
+  assert.match(JSON.parse(res.body).error, /enabled/u)
+})
+
+console.log('helper')
+
+ok('helper：缺参数时以退出码 1 结束', () => {
+  const result = spawnSync(process.execPath, [helperPath], { encoding: 'utf8' })
+  assert.equal(result.status, 1)
+})
+
+ok('helper：handoff 文件不存在时以退出码 1 结束', () => {
+  const result = spawnSync(process.execPath, [helperPath, join(tmpdir(), 'dsh-desktop-restart-missing.json')], { encoding: 'utf8' })
+  assert.equal(result.status, 1)
+})
+
+ok('helper：目标映像名不符时拒绝，且不启动任何进程', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'dsh-desktop-restart-smoke-'))
+  const logPath = join(dir, 'helper.log')
+  const handoffPath = join(dir, 'handoff.json')
+  writeFileSync(handoffPath, JSON.stringify({
+    mainPid: process.pid,
+    // 故意声明一个与当前进程映像名不同的目标：helper 必须拒绝。
+    exe: 'C:\\Windows\\System32\\notepad.exe',
+    hostPid: 1,
+    port: 0,
+    logPath,
+    delayMs: 50,
+  }), 'utf8')
+
+  const result = spawnSync(process.execPath, [helperPath, handoffPath], { encoding: 'utf8' })
+  assert.equal(result.status, 0)
+
+  const log = readFileSync(logPath, 'utf8')
+  assert.match(log, /refusing/u, 'helper 应当记录拒绝原因')
+  assert.doesNotMatch(log, /relaunched/u, 'helper 不应启动任何进程')
+})
+
+console.log('')
+console.log('all ' + String(passed) + ' checks passed')